home *** CD-ROM | disk | FTP | other *** search
/ Games of Daze / Infomagic - Games of Daze (Summer 1995) (Disc 1 of 2).iso / x2ftp / msdos / libs / bestl232 / !bestlib.h < prev    next >
C/C++ Source or Header  |  1994-09-03  |  149KB  |  2,840 lines
  1. /*==========================================================================
  2.  *
  3.  *  !BESTLIB.H  360 functions                        Friday, August 26, 1994
  4.  *
  5.  *  Definitions for The BESTLibrary v2.31
  6.  *  Designed for the Large memory model
  7.  *
  8.  *  Authored independently by George Vanous
  9.  *  Email any comments, compliments, or suggestions to vanous@helix.net
  10.  *
  11.  *==========================================================================*/
  12.  
  13.  
  14. /*  TABLE OF CONTENTS
  15. ------------------------
  16. = FILE
  17.     INI FILE
  18. = KEYBOARD
  19. = LINKED LIST
  20. = MATH
  21.     MATRIX
  22.     2D VECTORS
  23.     3D VECTORS
  24. = MISCELLANEOUS
  25. = MOUSE
  26. = STRING
  27.     CHARACTER
  28.     CONVERSION
  29. = TEXT MODE
  30.     ANIMATION
  31.     ATTRIBUTE
  32.     CHARACTER
  33.     CURSOR
  34.     GET
  35.     STRING
  36.     WINDOW
  37. = VGA
  38.     VGA16
  39.       IMAGE
  40.         COMPRESS IMAGE
  41.         PIXEL IMAGE
  42.         PLANE IMAGE
  43.     VGA256
  44. ------------------------*/
  45.  
  46. #if     !defined(__BESTLIB_DEF_)
  47. #define __BESTLIB_DEF_
  48.  
  49. #include <stdio.h>         /* necessary for "fil_count" and "fil_count_reg" */
  50.  
  51. /* ------------------------------------------------------------------------ */
  52. /* ---------------------------  COLOR CONSTANTS  -------------------------- */
  53.  
  54. #define BLACK        0x0                                              /* 00 */
  55. #define BLUE         0x1                                              /* 01 */
  56. #define GREEN        0x2                                              /* 02 */
  57. #define CYAN         0x3                                              /* 03 */
  58. #define RED          0x4                                              /* 04 */
  59. #define MAGENTA      0x5                                              /* 05 */
  60. #define BROWN        0x6                                              /* 06 */
  61. #define LIGHTGREY    0x7                                              /* 07 */
  62. #define DARKGREY     0x8                                              /* 08 */
  63. #define LIGHTBLUE    0x9                                              /* 09 */
  64. #define LIGHTGREEN   0xA                                              /* 10 */
  65. #define LIGHTCYAN    0xB                                              /* 11 */
  66. #define LIGHTRED     0xC                                              /* 12 */
  67. #define LIGHTMAGENTA 0xD                                              /* 13 */
  68. #define YELLOW       0xE                                              /* 14 */
  69. #define WHITE        0xF                                              /* 15 */
  70. #define BLINKCHAR    0x8   /* value to add to background color for blinking */
  71.  
  72. /* ------------------------------------------------------------------------ */
  73. /* --------------------------  NUMBER CONSTANTS  -------------------------- */
  74.  
  75. #define ZERO      0x0                                                 /* 00 */
  76. #define ONE       0x1                                                 /* 01 */
  77. #define TWO       0x2                                                 /* 02 */
  78. #define THREE     0x3                                                 /* 03 */
  79. #define FOUR      0x4                                                 /* 04 */
  80. #define FIVE      0x5                                                 /* 05 */
  81. #define SIX       0x6                                                 /* 06 */
  82. #define SEVEN     0x7                                                 /* 07 */
  83. #define EIGHT     0x8                                                 /* 08 */
  84. #define NINE      0x9                                                 /* 09 */
  85. #define TEN       0xA                                                 /* 10 */
  86. #define ELEVEN    0xB                                                 /* 11 */
  87. #define TWELVE    0xC                                                 /* 12 */
  88. #define THIRTEEN  0xD                                                 /* 13 */
  89. #define FOURTEEN  0xE                                                 /* 14 */
  90. #define FIFTEEN   0xF                                                 /* 15 */
  91. #define SIXTEEN   0x10                                                /* 16 */
  92. #define SEVENTEEN 0x11                                                /* 17 */
  93. #define EIGHTEEN  0x12                                                /* 18 */
  94. #define NINETEEN  0x13                                                /* 19 */
  95. #define TWENTY    0x14                                                /* 20 */
  96.  
  97. #define PI        3.14159265358979323846    /* the venerable pi             */
  98. #define PIby2     1.57079632679489661923    /* pi / 2 (180 degrees)         */
  99. #define PIby4     0.785398163397448309616   /* pi / 4 ( 45 degrees)         */
  100. #define E         2.71828182845904523536    /* the venerable e              */
  101. #define SQRT2     1.41421356237309504880    /* sqrt(2)                      */
  102. #define bySQRT2   0.707106781186547524401   /* 1 / sqrt(2)                  */
  103. #define DtoR      0.017453292519943295769   /* convert degrees to radians   */
  104. #define RtoD     57.2957795130823208768     /* convert radians to degrees   */
  105.  
  106. /* ------------------------------------------------------------------------ */
  107. /* ----------------------  GENERAL-PURPOSE CONSTANTS  --------------------- */
  108.  
  109. #define BYTE_MAX     255   /* maximum value taken on by type "byte"         */
  110. #define INT_MAX      32767 /* maximum value taken on by type "int"          */
  111. #define SHORTINT_MAX 127   /* maximum value taken on by type "shortint"     */
  112. #define WORD_MAX     65535L/* maximum value taken on by type "word"         */
  113. #define LONGU_MAX 4294967295 /* max value taken on by type "unsigned long"  */
  114. #define LONG_MAX  2147483647 /* maximum value taken on by type "long"       */
  115. #define CR '\r'            /* carriage return character                     */
  116. #define LF '\n'            /* linefeed character                            */
  117. #define NO  -1             /* logical constant                              */
  118. #define YES +1             /* logical constant                              */
  119. #define NONE      0        /* logical constant                              */
  120. #define OFF       0        /* logical constant                              */
  121. #define ON       +1        /* logical constant                              */
  122. #define BOTH     +2        /* logical constant                              */
  123. #define UNMODIFY +2        /* logical constant                              */
  124. #define FALSE 0            /* logical constant                              */
  125. #define TRUE !(FALSE)      /* logical constant                              */
  126. #define BACKWARD -1        /* logical constant                              */
  127. #define FORWARD  +1        /* logical constant                              */
  128. #define WARM 0x1234        /* warm boot identifier (like ctrl-alt-del)      */
  129. #define COLD 0             /* cold boot identifier (like pressing reset)    */
  130. #define MAX -1             /* logical constant                              */
  131. #define MIN -2             /* logical constant                              */
  132. #define MAXX        640    /* total screen x-length                         */
  133. #define MAXXHALF    320    /* half screen x-length                          */
  134. #define MAXMAXX     640    /* total (screen)+(virtual screen) x-length      */
  135. #define MAXMAXXHALF 320    /* half (screen)+(virtual screen) x-length       */
  136. #define MAXY        480    /* total screen y-height                         */
  137. #define MAXYHALF    240    /* half screen y-height                          */
  138. #define MAXMAXY     816    /* total (screen)+(virtual screen) y-height      */
  139. #define MAXMAXYHALF 408    /* half (screen)+(virtual screen) y-height       */
  140. #define WATCH_MAX   100    /* maximum number of stopwatches                 */
  141. #define SIGNED  -1         /* signed number                                 */
  142. #define UNSIGNED 1         /* unsigned number                               */
  143. #define TCUR 255           /* text cursor                                   */
  144. #define MCUR 254           /* mouse cursor                                  */
  145. #define MEM  253           /* memory cursor
  146.                               (coordinates are stored in memory)            */
  147. #define TEXTSAVE  0        /* store text video memory                       */
  148. #define TEXTSHOW  1        /* restore text video memory                     */
  149. #define TEXT      1        /* text mode                                     */
  150. #define TEXT25    3        /* 25-line text mode                             */
  151. #define TEXT50    2        /* 50-line text mode                             */
  152. #define TEXT25F  -1        /* forced 25-line text mode                      */
  153. #define TEXT50F  -2        /* forced 50-line text mode                      */
  154. #define VGA16    18        /* 640x480x16 graphics mode                      */
  155. #define VGA256   19        /* 320x200x256 graphics mode                     */
  156. #define TEXTPAGE1 0        /* text video page 1                             */
  157. #define TEXTPAGE2 1        /* text video page 2                             */
  158. #define TEXTPAGE3 2        /* text video page 3                             */
  159. #define TEXTPAGE4 3        /* text video page 4                             */
  160. #define TEXTPAGE5 4        /* text video page 5                             */
  161. #define TEXTPAGE6 5        /* text video page 6                             */
  162. #define TEXTPAGE7 6        /* text video page 7                             */
  163. #define TEXTPAGE8 7        /* text video page 8                             */
  164. #define TEXTPAGELAST   16  /* last video page: 4 for 50 line, 8 for 25 line */
  165. #define TEXTPAGEACTIVE -1  /* current active text video page                */
  166. #define TEXTPAGEVISUAL -2  /* current visual text video page                */
  167. #define TEXTIMAGE_OVERHEAD 8 /* byte overhead in "textimagedata"ed objects  */
  168. #define TOP    1           /* top (same as up)                              */
  169. #define UP     1           /* upward direction                              */
  170. #define LEFT   2           /* leftward direction                            */
  171. #define RIGHT  4           /* rightward direction                           */
  172. #define DOWN   8           /* downward direction                            */
  173. #define BOTTOM 8           /* bottom (same as down)                         */
  174. #define ALIGN_NONE  -1       /* perform no alignment when outputting text     */
  175. #define ALIGN_HORZ   0       /* horizontal center, shifting odd length left   */
  176. #define ALIGN_VERT   1       /* vertical center, shifting odd length up        */
  177. #define ALIGN_CENTER 2       /* horizontal and vertical center                */
  178. #define ALIGN_RIGHT  3     /* right justify text                            */
  179. #define COPY_IMAGE 0x0003  /* hexadecimal code for performing a direct copy */
  180. #define AND_IMAGE  0x0803  /* hexadecimal code for performing a logical AND */
  181. #define OR_IMAGE   0x1003  /* hexadecimal code for performing a locical OR  */
  182. #define XOR_IMAGE  0x1803  /* hexadecimal code for doing an eXclusive OR    */
  183. #define COPY_IMAGE_SET 0x0013  /* perform a direct copy and set to scroll   */
  184. #define AND_IMAGE_SET  0x0813  /* perform a logical AND and set to scroll   */
  185. #define OR_IMAGE_SET   0x1013  /* perform a locical OR  and set to scroll   */
  186. #define XOR_IMAGE_SET  0x1813  /* perform an eXclusive OR and set to scroll */
  187.  
  188. /* ------------------------------------------------------------------------ */
  189. /* ------------------------  ASCII CODE CONSTANTS  ------------------------ */
  190.  
  191. #define BACKSPACE   0x08                              /* backspace keypress */
  192. #define ESC         0x1B                                    /* ESC keypress */
  193. #define SPACE       0x20                                               /*   */
  194. #define QUOTE       0x22                                               /* " */
  195. #define APOSTROPHE  0x27                                               /* ' */
  196. #define HYPHEN      0x2D                                               /* - */
  197. #define BLOCK_SOLID 0xDB                                               /* █ */
  198.  
  199. /* ------------------------------------------------------------------------ */
  200. /* -------------------------  SCAN CODE CONSTANTS  ------------------------ */
  201.  
  202. #define SCAN_NONE                  0x00                              /*   0 */
  203. #define SCAN_ESC                   0x01                              /*   1 */
  204. #define SCAN_1                     0x02                              /*   2 */
  205. #define SCAN_2                     0x03                              /*   3 */
  206. #define SCAN_3                     0x04                              /*   4 */
  207. #define SCAN_4                     0x05                              /*   5 */
  208. #define SCAN_5                     0x06                              /*   6 */
  209. #define SCAN_6                     0x07                              /*   7 */
  210. #define SCAN_7                     0x08                              /*   8 */
  211. #define SCAN_8                     0x09                              /*   9 */
  212. #define SCAN_9                     0x0A                              /*  10 */
  213. #define SCAN_0                     0x0B                              /*  11 */
  214. #define SCAN_HYPHEN                0x0C                              /*  12 */
  215. #define SCAN_EQUAL                 0x0D                              /*  13 */
  216. #define SCAN_BACKSPACE             0x0E                              /*  14 */
  217. #define SCAN_TAB                   0x0F                              /*  15 */
  218. #define SCAN_Q                     0x10                              /*  16 */
  219. #define SCAN_W                     0x11                              /*  17 */
  220. #define SCAN_E                     0x12                              /*  18 */
  221. #define SCAN_R                     0x13                              /*  19 */
  222. #define SCAN_T                     0x14                              /*  20 */
  223. #define SCAN_Y                     0x15                              /*  21 */
  224. #define SCAN_U                     0x16                              /*  22 */
  225. #define SCAN_I                     0x17                              /*  23 */
  226. #define SCAN_O                     0x18                              /*  24 */
  227. #define SCAN_P                     0x19                              /*  25 */
  228. #define SCAN_BRACKET_LEFT          0x1A                              /*  26 */
  229. #define SCAN_BRACKET_RIGHT         0x1B                              /*  27 */
  230. #define SCAN_ENTER                 0x1C                              /*  28 */
  231. #define SCAN_CTRL                  0x1D                              /*  29 */
  232. #define SCAN_A                     0x1E                              /*  30 */
  233. #define SCAN_S                     0x1F                              /*  31 */
  234. #define SCAN_D                     0x20                              /*  32 */
  235. #define SCAN_F                     0x21                              /*  33 */
  236. #define SCAN_G                     0x22                              /*  34 */
  237. #define SCAN_H                     0x23                              /*  35 */
  238. #define SCAN_J                     0x24                              /*  36 */
  239. #define SCAN_K                     0x25                              /*  37 */
  240. #define SCAN_L                     0x26                              /*  38 */
  241. #define SCAN_SEMICOLON             0x27                              /*  39 */
  242. #define SCAN_QUOTE                 0x28                              /*  40 */
  243. #define SCAN_BACKQUOTE             0x29                              /*  41 */
  244. #define SCAN_SHIFT_LEFT            0x2A                              /*  42 */
  245. #define SCAN_BACKSLASH             0x2B                              /*  43 */
  246. #define SCAN_Z                     0x2C                              /*  44 */
  247. #define SCAN_X                     0x2D                              /*  45 */
  248. #define SCAN_C                     0x2E                              /*  46 */
  249. #define SCAN_V                     0x2F                              /*  47 */
  250. #define SCAN_B                     0x30                              /*  48 */
  251. #define SCAN_N                     0x31                              /*  49 */
  252. #define SCAN_M                     0x32                              /*  50 */
  253. #define SCAN_COMMA                 0x33                              /*  51 */
  254. #define SCAN_PERIOD                0x34                              /*  52 */
  255. #define SCAN_SLASH                 0x35                              /*  53 */
  256. #define SCAN_SHIFT_RIGHT           0x36                              /*  54 */
  257. #define SCAN_KEYPAD_ASTERISK       0x37                              /*  55 */
  258. #define SCAN_ALT                   0x38                              /*  56 */
  259. #define SCAN_SPACE                 0x39                              /*  57 */
  260. #define SCAN_CAPSLOCK              0x3A                              /*  58 */
  261. #define SCAN_F1                    0x3B                              /*  59 */
  262. #define SCAN_F2                    0x3C                              /*  60 */
  263. #define SCAN_F3                    0x3D                              /*  61 */
  264. #define SCAN_F4                    0x3E                              /*  62 */
  265. #define SCAN_F5                    0x3F                              /*  63 */
  266. #define SCAN_F6                    0x40                              /*  64 */
  267. #define SCAN_F7                    0x41                              /*  65 */
  268. #define SCAN_F8                    0x42                              /*  66 */
  269. #define SCAN_F9                    0x43                              /*  67 */
  270. #define SCAN_F10                   0x44                              /*  68 */
  271. #define SCAN_NUMLOCK               0x45                              /*  69 */
  272. #define SCAN_SCROLLOCK             0x46                              /*  70 */
  273. #define SCAN_HOME                  0x47                              /*  71 */
  274. #define SCAN_UP                    0x48                              /*  72 */
  275. #define SCAN_PGUP                  0x49                              /*  73 */
  276. #define SCAN_KEYPAD_MINUS          0x4A                              /*  74 */
  277. #define SCAN_LEFT                  0x4B                              /*  75 */
  278. #define SCAN_KEYPAD_5              0x4C                              /*  76 */
  279. #define SCAN_RIGHT                 0x4D                              /*  77 */
  280. #define SCAN_KEYPAD_PLUS           0x4E                              /*  78 */
  281. #define SCAN_END                   0x4F                              /*  79 */
  282. #define SCAN_DOWN                  0x50                              /*  80 */
  283. #define SCAN_PGDN                  0x51                              /*  81 */
  284. #define SCAN_INSERT                0x52                              /*  82 */
  285. #define SCAN_DELETE                0x53                              /*  83 */
  286. #define SCAN_SHIFT_F1              0x54                              /*  84 */
  287. #define SCAN_SHIFT_F2              0x55                              /*  85 */
  288. #define SCAN_SHIFT_F3              0x56                              /*  86 */
  289. #define SCAN_SHIFT_F4              0x57                              /*  87 */
  290. #define SCAN_SHIFT_F5              0x58                              /*  88 */
  291. #define SCAN_SHIFT_F6              0x59                              /*  89 */
  292. #define SCAN_SHIFT_F7              0x5A                              /*  90 */
  293. #define SCAN_SHIFT_F8              0x5B                              /*  91 */
  294. #define SCAN_SHIFT_F9              0x5C                              /*  92 */
  295. #define SCAN_SHIFT_F10             0x5D                              /*  93 */
  296. #define SCAN_CTRL_F1               0x5E                              /*  94 */
  297. #define SCAN_CTRL_F2               0x5F                              /*  95 */
  298. #define SCAN_CTRL_F3               0x60                              /*  96 */
  299. #define SCAN_CTRL_F4               0x61                              /*  97 */
  300. #define SCAN_CTRL_F5               0x62                              /*  98 */
  301. #define SCAN_CTRL_F6               0x63                              /*  99 */
  302. #define SCAN_CTRL_F7               0x64                              /* 100 */
  303. #define SCAN_CTRL_F8               0x65                              /* 101 */
  304. #define SCAN_CTRL_F9               0x66                              /* 102 */
  305. #define SCAN_CTRL_F10              0x67                              /* 103 */
  306. #define SCAN_ALT_F1                0x68                              /* 104 */
  307. #define SCAN_ALT_F2                0x69                              /* 105 */
  308. #define SCAN_ALT_F3                0x6A                              /* 106 */
  309. #define SCAN_ALT_F4                0x6B                              /* 107 */
  310. #define SCAN_ALT_F5                0x6C                              /* 108 */
  311. #define SCAN_ALT_F6                0x6D                              /* 109 */
  312. #define SCAN_ALT_F7                0x6E                              /* 110 */
  313. #define SCAN_ALT_F8                0x6F                              /* 111 */
  314. #define SCAN_ALT_F9                0x70                              /* 112 */
  315. #define SCAN_ALT_F10               0x71                              /* 113 */
  316. #define SCAN_CTRL_PRTSC            0x72                              /* 114 */
  317. #define SCAN_CTRL_LEFT             0x73                              /* 115 */
  318. #define SCAN_CTRL_RIGHT            0x74                              /* 116 */
  319. #define SCAN_CTRL_END              0x75                              /* 117 */
  320. #define SCAN_CTRL_PGDN             0x76                              /* 118 */
  321. #define SCAN_CTRL_HOME             0x77                              /* 119 */
  322. #define SCAN_ALT_1                 0x78                              /* 120 */
  323. #define SCAN_ALT_2                 0x79                              /* 121 */
  324. #define SCAN_ALT_3                 0x7A                              /* 122 */
  325. #define SCAN_ALT_4                 0x7B                              /* 123 */
  326. #define SCAN_ALT_5                 0x7C                              /* 124 */
  327. #define SCAN_ALT_6                 0x7D                              /* 125 */
  328. #define SCAN_ALT_7                 0x7E                              /* 126 */
  329. #define SCAN_ALT_8                 0x7F                              /* 127 */
  330. #define SCAN_ALT_9                 0x80                              /* 128 */
  331. #define SCAN_ALT_0                 0x81                              /* 129 */
  332. #define SCAN_ALT_HYPHEN            0x82                              /* 130 */
  333. #define SCAN_ALT_EQUAL             0x83                              /* 131 */
  334. #define SCAN_CTRL_PGUP             0x84                              /* 132 */
  335. #define SCAN_F11                   0x85                              /* 133 */
  336. #define SCAN_F12                   0x86                              /* 134 */
  337. #define SCAN_SHIFT_F11             0x87                              /* 135 */
  338. #define SCAN_SHIFT_F12             0x88                              /* 136 */
  339. #define SCAN_CTRL_F11              0x89                              /* 137 */
  340. #define SCAN_CTRL_F12              0x8A                              /* 138 */
  341. #define SCAN_ALT_F11               0x8B                              /* 139 */
  342. #define SCAN_ALT_F12               0x8C                              /* 140 */
  343. #define SCAN_CTRL_UP               0x8D                              /* 141 */
  344. #define SCAN_CTRL_KEYPAD_MINUS     0x8E                              /* 142 */
  345. #define SCAN_CTRL_KEYPAD_5         0x8F                              /* 143 */
  346. #define SCAN_CTRL_KEYPAD_PLUS      0x90                              /* 144 */
  347. #define SCAN_CTRL_DOWN             0x91                              /* 145 */
  348. #define SCAN_CTRL_INS              0x92                              /* 146 */
  349. #define SCAN_CTRL_DEL              0x93                              /* 147 */
  350. #define SCAN_CTRL_TAB              0x94                              /* 148 */
  351. #define SCAN_CTRL_KEYPAD_SLASH     0x95                              /* 149 */
  352. #define SCAN_CTRL_KEYPAD_ASTERISK  0x96                              /* 150 */
  353. #define SCAN_ALT_HOME              0x97                              /* 151 */
  354. #define SCAN_ALT_UP                0x98                              /* 152 */
  355. #define SCAN_ALT_PGUP              0x99                              /* 153 */
  356. //                                 0x9A                              /* 154 */
  357. #define SCAN_ALT_LEFT              0x9B                              /* 155 */
  358. //                                 0x9C                              /* 156 */
  359. #define SCAN_ALT_RIGHT             0x9D                              /* 157 */
  360. //                                 0x9E                              /* 158 */
  361. #define SCAN_ALT_END               0x9F                              /* 159 */
  362. #define SCAN_ALT_DOWN              0xA0                              /* 160 */
  363. #define SCAN_ALT_PGDN              0xA1                              /* 161 */
  364. #define SCAN_ALT_INS               0xA2                              /* 162 */
  365. #define SCAN_ALT_DEL               0xA3                              /* 163 */
  366. #define SCAN_ALT_SLASH             0xA4                              /* 164 */
  367. #define SCAN_ALT_TAB               0xA5                              /* 165 */
  368. #define SCAN_ALT_ENTER             0xA6                              /* 166 */
  369. //                                 0xA7                              /* 167 */
  370. //                                                                   /*     */
  371. #define SCAN_CTRL_ENTER            0xE0                              /* 224 */
  372.  
  373. /* ------------------------------------------------------------------------ */
  374. /* -----------------------  ASCII GRAPHIC CONSTANTS  ---------------------- */
  375.  
  376. #define HOUSE1L  0                                    /* house #1[left]     */
  377. #define HOUSE1R  1                                    /* house #1[right]    */
  378. #define TREE1    2                                    /* tree #1            */
  379. #define CAR1L    3                                    /* car #1[left]       */
  380. #define CAR1R    4                                    /* car #2[right]      */
  381. #define DINO1L   5                                    /* dinosaur #1[left]  */
  382. #define DINO1R   6                                    /* dinosaur #1[right] */
  383. #define SHIP1N   7                                    /* ship #1[N]         */
  384. #define SHIP1NE  8                                    /* ship #1[NE]        */
  385. #define SHIP1E   9                                    /* ship #1[E]         */
  386. #define SHIP1SE 10                                    /* ship #1[SE]        */
  387. #define SHIP1S  11                                    /* ship #1[S]         */
  388. #define SHIP1SW 12                                    /* ship #1[SW]        */
  389. #define SHIP1W  13                                    /* ship #1[W]         */
  390. #define SHIP1NW 14                                    /* ship #1[NW]        */
  391. #define BIRD1   15                                    /* bird #1            */
  392. #define DIAMON1 16                                    /* diamond #1         */
  393. #define EXPLOS1 17                                    /* explosion #1       */
  394. #define TOOTHG1 18                                    /* toothgrin #1       */
  395. #define HOURGL1 19                                    /* hourglass #1       */
  396. #define METEOR1 20                                    /* meteor #1          */
  397. #define SPACES1 21                                    /* spaceship #1       */
  398. #define BIKERL1 22                                    /* biker #1[left]     */
  399. #define BIKERR1 23                                    /* biker #1[right]    */
  400. #define FROWN1  24                                    /* frown #1           */
  401. #define GRIN1   25                                    /* grin #1            */
  402. #define LAMP1L  26                                    /* lamp #1[left]      */
  403. #define LAMP1R  27                                    /* lamp #1[right]     */
  404. #define SAILB1L 28                                    /* sailboat #1[left]  */
  405. #define SAILB1R 29                                    /* sailboat #1[right] */
  406. #define SHARK1L 30                                    /* shark #1[left]     */
  407. #define SHARK1R 31                                    /* shark #1[right]    */
  408. #define TARGET1 32                                    /* target #1          */
  409. #define TRUCK1L 33                                    /* truck #1[left]     */
  410. #define TRUCK1R 34                                    /* truck #1[right]    */
  411. #define VAN1L   35                                    /* van #1[left]       */
  412. #define VAN1R   36                                    /* van #1[right]      */
  413. #define BALLO11 37                                    /* balloon #1[1]      */
  414. #define BALLO12 38                                    /* balloon #1[2]      */
  415. #define BALLO13 39                                    /* balloon #1[3]      */
  416. #define SUN1    40                                    /* sun #1             */
  417. #define FIGUR3L 41                                    /* figure #3[left]    */
  418. #define FIGUR3R 42                                    /* figure #3[right]   */
  419. #define FIGUR41 43                                    /* figure #4[1]       */
  420. #define FIGUR42 44                                    /* figure #4[2]       */
  421. #define FIGUR52 45                                    /* figure #5[2]       */
  422. #define FISH1L  46                                    /* fish #1[left]      */
  423. #define FISH1R  47                                    /* fish #1[right]     */
  424. #define FISH2L  48                                    /* fish #2[left]      */
  425. #define FISH2R  49                                    /* fish #2[right]     */
  426. #define PLANE1L 50                                    /* plane #1[left]     */
  427. #define PLANE1R 51                                    /* plane #1[right]    */
  428. #define JET1L   52                                    /* jet #1[left]       */
  429. #define JET1R   53                                    /* jet #1[right]      */
  430.  
  431. #define TARGET2 54                                    /* target #2          */
  432. #define BOTTLE1 55                                    /* bottle #1          */
  433. #define FIGUR1L 56                                    /* figure #1[left]    */
  434. #define FIGUR1R 57                                    /* figure #1[right]   */
  435. #define FIGUR2L 58                                    /* figure #2[left]    */
  436. #define FIGUR2R 59                                    /* figure #2[right]   */
  437. #define FIGUR51 60                                    /* figure #5[1]       */
  438. #define FIGUR6L 61                                    /* figure #6[left]    */
  439. #define FIGUR6R 62                                    /* figure #6[right]   */
  440. #define MOON1L  63                                    /* moon #1[left]      */
  441. #define MOON1R  64                                    /* moon #1[right]     */
  442.  
  443. /* ------------------------------------------------------------------------ */
  444. /* ----------------------  ASCII GRAPHIC DEFINITIONS  --------------------- */
  445.  
  446. /*                           paste this array into the program that uses it
  447. byte codes[] = {
  448.   (word)HOUSE1L, 192,126,                             /* house #1[left]     */
  449.   (word)HOUSE1R, 193,127,                             /* house #1[right]    */
  450.   (word)TREE1  , 194,145,                             /* tree #1            */
  451.   (word)CAR1L  , 195,146,                             /* car #1[left]       */
  452.   (word)CAR1R  , 196,164,                             /* car #2[right]      */
  453.   (word)DINO1L , 197,165,                             /* dinosaur #1[left]  */
  454.   (word)DINO1R , 198,166,                             /* dinosaur #1[right] */
  455.   (word)SHIP1N , 199,167,                             /* ship #1[N]         */
  456.   (word)SHIP1NE, 200,168,                             /* ship #1[NE]        */
  457.   (word)SHIP1E , 201,169,                             /* ship #1[E]         */
  458.   (word)SHIP1SE, 202,170,                             /* ship #1[SE]        */
  459.   (word)SHIP1S , 203,171,                             /* ship #1[S]         */
  460.   (word)SHIP1SW, 204,172,                             /* ship #1[SW]        */
  461.   (word)SHIP1W , 205,173,                             /* ship #1[W]         */
  462.   (word)SHIP1NW, 206,174,                             /* ship #1[NW]        */
  463.   (word)BIRD1  , 207,175,                             /* bird #1            */
  464.   (word)DIAMON1, 208,179,                             /* diamond #1         */
  465.   (word)EXPLOS1, 209,180,                             /* explosion #1       */
  466.   (word)TOOTHG1, 210,181,                             /* toothgrin #1       */
  467.   (word)HOURGL1, 211,182,                             /* hourglass #1       */
  468.   (word)METEOR1, 212,183,                             /* meteor #1          */
  469.   (word)SPACES1, 213,184,                             /* spaceship #1       */
  470.   (word)BIKERL1, 214,185,                             /* biker #1[left]     */
  471.   (word)BIKERR1, 215,186,                             /* biker #1[right]    */
  472.   (word)FROWN1 , 216,187,                             /* frown #1           */
  473.   (word)GRIN1  , 217,188,                             /* grin #1            */
  474.   (word)LAMP1L , 218,189,                             /* lamp #1[left]      */
  475.   (word)LAMP1R , 219,190,                             /* lamp #1[right]     */
  476.   (word)SAILB1L, 220,191,                             /* sailboat #1[left]  */
  477.   (word)SAILB1R, 221,224,                             /* sailboat #1[right] */
  478.   (word)SHARK1L, 222,225,                             /* shark #1[left]     */
  479.   (word)SHARK1R, 223,226,                             /* shark #1[right]    */
  480.  
  481.   (word)TARGET1, 192,126,                             /* target #1          */
  482.   (word)TRUCK1L, 193,127,                             /* truck #1[left]     */
  483.   (word)TRUCK1R, 194,145,                             /* truck #1[right]    */
  484.   (word)VAN1L  , 195,146,                             /* van #1[left]       */
  485.   (word)VAN1R  , 196,164,                             /* van #1[right]      */
  486.   (word)BALLO11, 197,165,                             /* balloon #1[1]      */
  487.   (word)BALLO12, 198,166,                             /* balloon #1[2]      */
  488.   (word)BALLO13, 199,167,                             /* balloon #1[3]      */
  489.   (word)SUN1   , 200,168,                             /* sun #1             */
  490.   (word)FIGUR3L, 201,169,                             /* figure #3[left]    */
  491.   (word)FIGUR3R, 202,170,                             /* figure #3[right]   */
  492.   (word)FIGUR41, 203,171,                             /* figure #4[1]       */
  493.   (word)FIGUR42, 204,172,                             /* figure #4[2]       */
  494.   (word)FIGUR52, 205,173,                             /* figure #5[2]       */
  495.   (word)FISH1L , 206,174,                             /* fish #1[left]      */
  496.   (word)FISH1R , 207,175,                             /* fish #1[right]     */
  497.   (word)FISH2L , 208,179,                             /* fish #2[left]      */
  498.   (word)FISH2R , 209,180,                             /* fish #2[right]     */
  499.   (word)PLANE1L, 210,181,                             /* plane #1[left]     */
  500.   (word)PLANE1R, 211,182,                             /* plane #1[right]    */
  501.   (word)JET1L  , 212,183,                             /* jet #1[left]       */
  502.   (word)JET1R  , 213,184,                             /* jet #1[right]      */
  503.  
  504.   (word)TARGET2, 255,                                 /* target #2          */
  505.   (word)BOTTLE1, 254,                                 /* bottle #1          */
  506.   (word)FIGUR1L, 253,                                 /* figure #1[left]    */
  507.   (word)FIGUR1R, 252,                                 /* figure #1[right]   */
  508.   (word)FIGUR2L, 251,                                 /* figure #2[left]    */
  509.   (word)FIGUR2R, 250,                                 /* figure #2[right]   */
  510.   (word)FIGUR51, 249,                                 /* figure #5[1]       */
  511.   (word)FIGUR6L, 248,                                 /* figure #6[left]    */
  512.   (word)FIGUR6R, 247,                                 /* figure #6[right]   */
  513.   (word)MOON1L , 246,                                 /* moon #1[left]      */
  514.   (word)MOON1R , 245                                  /* moon #1[right]     */
  515. }; */
  516.  
  517. /* ------------------------------------------------------------------------ */
  518. /* ------------------------------  MESSAGES  ------------------------------ */
  519.  
  520. #define DASHES printf("\n--------------------------------------------------------------------------------")
  521. #define DISTRIBUTE printf("\n-------------------------  DISTRIBUTION IS ENCOURAGED  -------------------------")
  522. #define DOUBLESPACE printf("\n\n")
  523. #define SINGLESPACE printf("\n")
  524.  
  525. /* ------------------------------------------------------------------------ */
  526. /* -------------------------------  MACROS  ------------------------------- */
  527.  
  528. #define ischar(ch) (((ch >= 'A' && ch <= 'Z') || (ch >= 'a' && ch <= 'z') || ch == APOSTROPHE || ch == HYPHEN) ? TRUE : FALSE)
  529. /* RETURNS:  TRUE if 'ch' is a valid character used in words
  530.             FALSE if 'ch' is not a valid character used in words            */
  531.  
  532. /*----------------------------------------------------------------------------
  533.  * ONE-ARGUMENT MACROS                                                      */
  534.  
  535. /* absolute value of a */
  536. #define ABS(a)     (((a)<0) ? -(a) : (a))
  537.  
  538. /* round a to nearest integer towards 0 */
  539. #define FLOOR(a)   ((a)>0 ? (int)(a) : -(int)(-a))
  540.  
  541. /* round a to nearest integer away from 0 */
  542. #define CEILING(a) ( (a) == (int)(a) ? (a) \
  543.                    : (a) > 0 ? 1+(int)(a) : -( 1+(int)(-a) ))
  544.  
  545. /* round a to nearest int */
  546. #define ROUND(a)   (((a) > 0) ? (int)(a+0.5) : -(int)(0.5-a))
  547.  
  548. /* take sign of a, either -1, 0, or 1 */
  549. #define ZSGN(a)    (((a) < 0) ? -1 : (a) > 0 ? 1 : 0)
  550.  
  551. /* take binary sign of a, either -1, or 1 if >= 0 */
  552. #define SGN(a)     (((a) < 0) ? -1 : 1)
  553.  
  554. /* shout if something that should be true isn't */
  555. #define ASSERT(x)  if (!(x)) fprintf(stderr," Assert failed: x\n");
  556.  
  557. /* square a */
  558. #define SQR(a)     ((a)*(a))
  559.  
  560. /*----------------------------------------------------------------------------
  561.  * TWO-ARGUMENT MACROS                                                      */
  562.  
  563. /* return minimum of a and b */
  564. #define MINIMUM(a,b)    ( ((a) < (b)) ? (a) : (b) )
  565.  
  566. /* return maximum of a and b */
  567. #define MAXIMUM(a,b)    ( ((a) > (b)) ? (a) : (b) )
  568.  
  569. /* swap a and b (see Gem by Wyvill) */
  570. #define SWAP(a,b)       { a^=b; b^=a; a^=b; }
  571.  
  572. /* linear interpolation from l (when a=0) to h (when a=1) */
  573. /* (equal to (a*h) + ( (1-a) * l)                         */
  574. #define LERP(a,l,h)     ( (l) + (((h)-(l)) * (a)) )
  575.  
  576. /* clamp the input to the specified range */
  577. #define CLAMP(v,l,h)    ( (v) < (l) ? (l) : (v) > (h) ? (h) : v)
  578.  
  579. /*----------------------------------------------------------------------------
  580.  * MEMORY ALLOCATION MACROS                                                 */
  581.  
  582. /* create a new instance of a structure (see Gem by Hultquist) */
  583. #define NEWSTRUCT(x) (struct x *) (malloc( (unsigned)sizeof(struct x) ))
  584.  
  585. /* create a new instance of a type */
  586. #define NEWTYPE(x) (x *) (malloc( (unsigned)sizeof(x) ))
  587.  
  588. /* ------------------------------------------------------------------------ */
  589. /* --------------------------  TYPE DEFINITIONS  -------------------------- */
  590.  
  591. typedef unsigned char boolean;          /* TRUE or FALSE type as in Pascal  */
  592. typedef boolean flag;                   /* flag data type                   */
  593. typedef unsigned char byte;             /* (0-255) type as in Pascal        */
  594. typedef signed char shortint;           /* (-128 to +127) type as in Pascal */
  595. typedef unsigned int word;              /* (0-65535) type as in Pascal      */
  596.  
  597. typedef struct {
  598.   char ascii;          /* ASCII code of character pressed                   */
  599.   byte scan;           /* SCAN code of character pressed                    */
  600. } asciiscan;
  601.  
  602. typedef struct {
  603.   byte y;              /* ordinate                                          */
  604.   byte x;              /* abscissa                                          */
  605.   byte start;          /* starting scan line                                */
  606.   byte end;            /* ending scan line                                  */
  607.   boolean on;          /* TRUE if text cursor is on, FALSE if it is not on  */
  608. } cursordata;
  609.  
  610. typedef struct document_def {
  611.   char  *line;                  /* pointer to a line of the document        */
  612.   struct document_def *prev;    /* pointer to previous line                 */
  613.   struct document_def *next;    /* pointer to next line                     */
  614. } document;
  615.  
  616. typedef struct {
  617.   shortint fgclr;      /* foreground color or NO if no color fill           */
  618.   shortint bgclr;      /* background color or NO if no color fill           */
  619.   char fillchar;       /* character to fill with or NO if no character fill */
  620.   byte x;              /* abscissa (if TCUR, uses text cursor abscissa
  621.                                     if MCUR, uses mouse cursor abscissa)    */
  622.   byte y;              /* ordinate (if TCUR, uses text cursor ordinate
  623.                                     if MCUR, uses mouse cursor ordinate)    */
  624.   shortint length;     /* x-length                                          */
  625.   shortint height;     /* y-height                                          */
  626.   char *overwrite;     /* text to overwrite or NULL if overwrite all        */
  627.   char *text;          /* text to print or NULL if no text                  */
  628. } filldata;
  629.  
  630. typedef struct {
  631.   word size;           /* size of image in bytes                            */
  632.   byte tclr;           /* transparency color of image
  633.            * or number of 8-pixel groups per row if image is "_16_i_save"ed */
  634.   int x;               /* abscissa (if MCUR, uses mouse abscissa)           */
  635.   int y;               /* abscissa (if MCUR, uses mouse ordinate)           */
  636.   int length;          /* x-length (do not modify)                          */
  637.   int height;          /* y-height (do not modify)                          */
  638.   int how : 1;         /* relative to current scroll (TRUE) or not (FALSE)  */
  639.   int for_future : 15; /* no current purpose other than filling the integer */
  640. } imagedata;
  641.  
  642. typedef struct linked_list {
  643.   struct linked_list *next;     /* pointer to next node                     */
  644. } llist;
  645.  
  646. typedef struct linked_list_s {
  647.   struct linked_list_s *next;   /* pointer to next node                     */
  648. } llist_single;
  649.  
  650. typedef struct linked_list_d {
  651.   struct linked_list_d *prev;   /* pointer to previous node                 */
  652.   struct linked_list_d *next;   /* pointer to next node                     */
  653. } llist_double;
  654.  
  655. typedef struct {
  656.   byte update;         /*  TRUE "ms_stat" has updated structure "mousedata" */
  657.                        /* FALSE no structure variables have been updated    */
  658.   int pos[2];          /* old mouse cursor x,y position                     */
  659.   int buts[2];         /* old left,right button  0 not pressed  1 pressed   */
  660.   int npos[2];         /* new mouse cursor x,y position                     */
  661.   int nbuts[2];        /* new left,right button  0 not pressed  1 pressed   */
  662.   int butlr[2];        /* x,y position of last left button release          */
  663.   int butlp[2];        /* x,y position of last left button press            */
  664.   int butrr[2];        /* x,y position of last right button release         */
  665.   int butrp[2];        /* x,y position of last right button press           */
  666. } mousedata;
  667.  
  668. typedef struct {
  669.   shortint fgclr;      /* foreground color or NO if no color fill           */
  670.   shortint bgclr;      /* background color or NO if no color fill           */
  671.   byte command;  /* ALIGN_NONE   - no command
  672.                   * ALIGN_HORZ   - horizontal center; shifts odd lengths left
  673.                   * ALIGN_VERT   - vertical center; shifts odd lengths up
  674.                   * ALIGN_CENTER - horizontal and vertical center
  675.                   * ALIGN_RIGHT  - right justify; flush to right margin     */
  676.   byte x;              /* abscissa (if TCUR, uses text cursor abscissa
  677.                                     if MCUR, uses mouse cursor abscissa)    */
  678.   byte y;              /* ordinate (if TCUR, uses text cursor ordinate
  679.                                     if MCUR, uses mouse cursor ordinate)    */
  680.   char *text;          /* text to print                                     */
  681. } printdata;
  682.  
  683. typedef struct {
  684.   word size;           /* size of image in bytes                            */
  685.   shortint fgclr;      /* NO if no color fill                               */
  686.   shortint bgclr;      /* NO if no color fill                               */
  687.   byte x;              /* abscissa (if TCUR, uses text cursor abscissa
  688.                                     if MCUR, uses mouse cursor abscissa)    */
  689.   byte y;              /* ordinate (if TCUR, uses text cursor ordinate
  690.                                     if MCUR, uses mouse cursor ordinate)    */
  691.   byte length;         /* x-length (do not modify)                          */
  692.   byte height;         /* y-height (do not modify)                          */
  693. } textimagedata;
  694.  
  695. typedef struct {
  696.   shortint fgclr;      /* foreground color or NO if no color fill           */
  697.   shortint bgclr;      /* background color or NO if no color fill           */
  698.   byte x;              /* abscissa (if TCUR, uses text cursor abscissa
  699.                                     if MCUR, uses mouse cursor abscissa)    */
  700.   byte y;              /* ordinate (if TCUR, uses text cursor ordinate
  701.                                     if MCUR, uses mouse cursor ordinate)    */
  702. } textstr;
  703.  
  704. typedef struct {
  705.   byte  fgclr, bgclr,                /* color of text inside window         */
  706.         x, y,                        /* top,left coordinates of window      */
  707.         length, height,              /* length and height of window         */
  708.         parts,                       /* window parts to use                 */
  709.         shadow_style,                /* shadow style                        */
  710.         border_fgclr, border_bgclr,  /* color of border                     */
  711.         shadow_fgclr, shadow_bgclr,  /* color of shadow                     */
  712.         title_fgclr, title_bgclr;    /* color of title                      */
  713.   char *border,                      /* border characters                   */
  714.        *shadow,                      /* shadow characters                   */
  715.        *title;                       /* window title                        */
  716.   document *text;                    /* pointer to text of window           */
  717. } windowdata;
  718.  
  719. /* Valid shadow styles are any combination of directions, like BOTTOM+RIGHT */
  720.  
  721. /* WINDOW PARTS */
  722. #define CLOSE        1               /* close window button                 */
  723. #define ZOOM         2               /* zoom window button                  */
  724. #define RESIZE       4               /* resize window button                */
  725. #define HORIZ_SCROLL 8               /* horizontal scroll bar               */
  726. #define VERT_SCROLL  16              /* vertical scroll bar                 */
  727. #define COORDS       32              /* display cursor coordinates          */
  728.  
  729. /* WINDOW BORDER DEFINITIONS */
  730. #define SINGLE      "
  731. #define SINGLE_SIDE "
  732. #define SINGLE_TOP  "
  733. #define DOUBLE      "
  734. #define DOUBLE_SIDE "
  735. #define DOUBLE_TOP  "
  736.  
  737. /*----------------------------------------------------------------------------
  738.  * 2-D GEOMETRY TYPES                                                       */
  739.  
  740. typedef struct point2_struct {         /* 2d point                          */
  741.   double x, y;
  742. } point2;
  743.  
  744. typedef point2 vector2;
  745.  
  746. typedef struct point2_int_struct {     /* 2d integer point                  */
  747.   int x, y;
  748. } point2_int;
  749.  
  750. typedef struct matrix3_struct {        /* 3-by-3 matrix                     */
  751.   double element[3][3];
  752. } matrix3;
  753.  
  754. typedef struct box2d_struct {          /* 2d box                            */
  755.   point2 min, max;
  756. } box2;
  757.  
  758. /*----------------------------------------------------------------------------
  759.  * 3-D GEOMETRY TYPES                                                       */
  760.  
  761. typedef struct point3_struct {         /* 3d point                          */
  762.   double x, y, z;
  763. } point3;
  764.  
  765. typedef point3 vector3;
  766.  
  767. typedef struct point3_int_struct {     /* 3d integer point                  */
  768.   int x, y, z;
  769. } point3_int;
  770.  
  771. typedef struct matrix4_struct {        /* 4-by-4 matrix                     */
  772.   double element[4][4];
  773. } matrix4;
  774.  
  775. typedef struct box3d_struct {          /* 3d box                            */
  776.   point3 min, max;
  777. } box3;
  778.  
  779. /* ------------------------------------------------------------------------ */
  780. /* ---------------------  GLOBAL VARIABLE DEFINITIONS  -------------------- */
  781.  
  782. volatile extern boolean blink;                          /* default is TRUE  */
  783. /*      blink = TRUE  if blinking characters and 8 background colors
  784.    else blink = FALSE if no blinking characters and 16 background colors    */
  785.  
  786. volatile extern boolean mousepresent;                   /* default is FALSE */
  787. /*      mousepresent = TRUE if mouse is detected by function "ms_init"
  788.    else mousepresent = FALSE if mouse is not found by function "ms_init"    */
  789.  
  790. volatile extern word chr_output;                        /* default is MAX   */
  791. /* chr_output = maximum number of characters to print with any output
  792.                 subroutine (useful for windowing text)
  793.               = MAX for no limit on the number of characters to print       */
  794.  
  795. volatile extern boolean txt_cur_move;                   /* default is TRUE  */
  796. /*      txt_cur_move = TRUE  if text cursor will move if x = y = TCUR
  797.    else txt_cur_move = FALSE if text cursor will not move if x = y = TCUR   */
  798.  
  799. volatile extern word txt_length;                        /* default is 80    */
  800. /* character length of virtual text screen (used when smooth scrolling)     */
  801.  
  802. /* ------------------------------------------------------------------------ */
  803. /* ----------------------  FILE FUNCTION PROTOTYPES  ---------------------- */
  804.  
  805. FILE *fil_count(char *filename,
  806.                  char *title, char *author, char *msgs[], word msg_num);
  807. /* opens text data file "filename" and records number of program executions
  808.  * uses program name "title" and author name "author"
  809.  * must be in a text mode or nothing will print
  810.  * prints one random comment from "msgs", holding "msg_num" messages
  811.  * prints amount of memory available to program
  812.  * NOTE #include <alloc.h> must be present or free memory will be inaccurate
  813.  * RETURNS: file handle to data file                                        */
  814.  
  815. FILE *fil_count_reg(char *filename, char *title,
  816.                     char *author, char *registree);
  817. /* counter registered
  818.  * opens text data file "filename" and records number of program executions
  819.  * uses program name "title" and author name "author"
  820.  * must be in a text mode or nothing will print
  821.  * prints to whom the program is registered to
  822.  * prints amount of memory available to program
  823.  * NOTE #include <alloc.h> must be present or free memory will be inaccurate
  824.  * RETURNS: file handle to data file                                        */
  825.  
  826. long fil_len(FILE *f);
  827. /* RETURNS: byte length of file "f"                                         */
  828.  
  829. char *fil_next_str(word *size, FILE *f);
  830. /* read next string from file position "f" (a string can consist of
  831.    alphanumeric characters, hyphens, apostrophes, or text surrounded in
  832.    quotes, like "It is: 04/12/94" -- nothing else)
  833.  * initially allocates an input buffer of "size" bytes -- if needs more,
  834.      allocates "size" more bytes, and so on (modifies "size")
  835.  * RETURNS: pointer to next string (file pointer is set to byte following
  836.               string)
  837.  *          NULL if no string was found (file pointer is set to EOF)        */
  838.  
  839. char *fil_next_word(word *size, FILE *f);
  840. /* read next word from file position "f" (a word can consist of alphabet
  841.    letters, hyphens, or apostrophes) -- nothing else
  842.  * initially allocates an input buffer of "size" bytes -- if needs more,
  843.      allocates "size" more bytes, and so on (modifies "size")
  844.  * RETURNS: pointer to next word (file pointer is set to byte following word)
  845.  *          NULL if no word was found (file pointer is set to EOF)          */
  846.  
  847. char *fil_read_to(char *str, word *size, FILE *f);
  848. /* read from file position "f" upto first occurrence of "str"
  849.  * initially allocates an input buffer of "size" bytes -- if needs more,
  850.      allocates "size" more bytes, and so on (modifies "size")
  851.  * RETURNS: pointer to contents of file read in (file pointer is set to byte
  852.               just beyond match
  853.  *          NULL if no match was found (file pointer is set to EOF)         */
  854.  
  855. char *fil_read_to_strip(char *str, word *size, FILE *f);
  856. /* read from file position "f" upto first occurrence of "str"
  857.  * initially allocates an input buffer of "size" bytes -- if needs more,
  858.      allocates "size" more bytes, and so on (modifies "size")
  859.  * all comments (beginning with a ';'), blank lines, and extra spaces are
  860.      stripped, and '=' are moved directly adjacent to text to conserve memory.
  861.  * for example, the following passage:
  862.  
  863.  
  864.        This   is  "not; [I] =  say"      ;he said
  865.      [not ["I"] say]
  866.  
  867.       to  = this.
  868.  
  869.    becomes:
  870.  
  871.    This is "not; [I] =  say"
  872.    [not ["I"] say]
  873.    to=this.
  874.  
  875.    NOTE - text inside quotation marks (ie. string) is unaltered (and '[' ']'
  876.           are also considered to be quotation marks)
  877.  * RETURNS: pointer to contents of file read in (file pointer is set to byte
  878.               just beyond match
  879.  *          NULL if no match was found (file pointer is set to EOF)         */
  880.  
  881. word fil_skip_past(char *str, FILE *f);
  882. /* Search file "f" for "str" and set file pointer to just past it (or to EOF
  883.      if no match found).
  884.  * RETURNS: number of bytes scanned upto (and including) last byte of match
  885.  *          FALSE if no match was found                                     */
  886.  
  887. word fil_skip_to(char *str, FILE *f);
  888. /* Search file "f" for "str" and set file pointer to beginning of it (or to
  889.      EOF if no match found).
  890.  * RETURNS: number of bytes scanned upto (and including) first byte of match
  891.  *          FALSE if no match was found                                     */
  892.  
  893. /* ------------------------------------------------------------------------ */
  894. /* --------------------  INI FILE FUNCTION PROTOTYPES  -------------------- */
  895.  
  896. boolean ini_get_boolean(char *section, char *section_title, char *option);
  897. /* read parameter from text "section", title, "section_title", option "option"
  898.  * RETURNS: TRUE  if "TRUE"
  899.             FALSE if "FALSE"                                                */
  900.  
  901. byte ini_get_color(char *section, char *section_title, char *option);
  902. /* read parameter from text "section", title, "section_title", option "option"
  903.  * valid colors are "BLACK", "BLUE", "GREEN", "CYAN", "RED", "MAGENTA",
  904.    "BROWN", "LIGHTGREY", "DARKGREY", "LIGHTBLUE", "LIGHTGREEN", "LIGHTCYAN",
  905.    "LIGHTRED", "LIGHTMAGENTA", "YELLOW", "WHITE"
  906.  * RETURNS: color                                                           */
  907.  
  908. int ini_get_number(char *section, char *section_title, char *option);
  909. /* reads from .INI text "section", "section_title"
  910.  * RETURNS: number                                                          */
  911.  
  912. int ini_get_position(char *section, char *section_title, char *option);
  913. /* read parameter from text "section", title, "section_title", option "option"
  914.  * valid screen positions are "TOP", "BOTTOM"
  915.  * RETURNS: screen row number                                               */
  916.  
  917. int ini_get_rows(char *section, char *section_title, char *option);
  918. /* read parameter from text "section", title, "section_title", option "option"
  919.  * valid rows-per-screen are "25", "50", "UNMODIFY"
  920.  * RETURNS: rows-per-screen                                                 */
  921.  
  922. byte ini_get_state(char *section, char *section_title, char *option);
  923. /* read parameter from text "section", title, "section_title", option "option"
  924.  * valid keyboard states are "ON", "OFF", "UNMODIFY"
  925.  * RETURNS: 0 if "OFF"
  926.             1 if "ON"
  927.             2 if "UNMODIFY"                                                 */
  928.  
  929. char *ini_get_text(char *section, char *section_title, char *option);
  930. /* read parameter from text "section", title, "section_title", option "option"
  931.  * valid text must be enclosed within quotes
  932.  * RETURNS: text string                                                     */
  933.  
  934. boolean ini_get_yesno(char *section, char *section_title, char *option);
  935. /* reads from .INI text "section", "section_title"
  936.  * valid responses are "YES", "NO"
  937.  * RETURNS: TRUE  if "YES"
  938.             FALSE if "NO"                                                   */
  939.  
  940. char *ini_read_section(char *str1, char *str2, FILE *f);
  941. /* reads in relevant text from .INI file handle "f", beginning at "str1"
  942.    and ending at "str2"
  943.  * see "fil_read_to_strip" to see what is stripped and what is kept
  944.  * RETURNS: relevant section text                                           */
  945.  
  946. /* ------------------------------------------------------------------------ */
  947. /* --------------------  KEYBOARD FUNCTION PROTOTYPES  -------------------- */
  948.  
  949. char getchr(void);
  950. /* gets next available keypress; if no keypress available, waits for one
  951.  * ASCII code and scan code is returned in structure "asciiscan"
  952.  * RETURNS: ASCII code                                                      */
  953.  
  954. char getchre(byte x, byte y);
  955. /* gets next available keypress and echoes it to "x","y"; if no keypress
  956.    available, waits for one
  957.  * ASCII code and scan code is returned in structure "asciiscan"
  958.  * RETURNS: ASCII code                                                      */
  959.  
  960. char kbd_clear(void);
  961. /* clears keyboard buffer
  962.  * RETURNS: ASCII code of last character that was in buffer                 */
  963.  
  964. void kbd_give(void);
  965. /* gives control back to original keyboard intterupt                        */
  966.  
  967. void kbd_rate(byte rate, byte delay);
  968. /* set typematic "rate" and typematic "delay" for repeat-key action
  969.                                +-----+--------+
  970.                                |delay|millisec|
  971.                                +-----+--------+
  972.                                |   0 | 250    |
  973.                    |   1 | 500    |
  974.                    |   2 | 750    |
  975.                    |   3 | 1000   |
  976.                    +-----+--------+
  977.    +----+---------+ +----+---------+ +----+---------+ +----+---------+
  978.    |rate|chars/sec| |rate|chars/sec| |rate|chars/sec| |rate|chars/sec|
  979.    +----+---------+ +----+---------+ +----+---------+ +----+---------+
  980.    |  0 | 30.0      | |  8 | 15.0    | | 16 | 7.5     | | 24 | 3.7     |
  981.    |  1 | 26.7      | |  9 | 13.3    | | 17 | 6.7     | | 25 | 3.3     |
  982.    |  2 | 24.0      | | 10 | 12.0    | | 18 | 6.0     | | 26 | 3.0     |
  983.    |  3 | 21.8      | | 11 | 10.9    | | 19 | 5.5     | | 27 | 2.7     |
  984.    |  4 | 20.0      | | 12 | 10.0    | | 20 | 5.0     | | 28 | 2.5     |
  985.    |  5 | 18.5      | | 13 |  9.2    | | 21 | 4.6     | | 29 | 2.3     |
  986.    |  6 | 17.1      | | 14 |  8.6    | | 22 | 4.3     | | 30 | 2.1     |
  987.    |  7 | 16.0      | | 15 |  8.0       | | 23 | 4.0     | | 31 | 2.0     |
  988.    +----+---------+ +----+---------+ +----+---------+ +----+---------+      */
  989.  
  990. void kbd_status_load(void);
  991. /* restores saved keyboard status of insert, caps/num/scroll lock           */
  992.  
  993. void kbd_status_save(void);
  994. /* saves current keyboard status of insert, caps/num/scroll lock            */
  995.  
  996. void kbd_take(void);
  997. /* takes control of the keyboard interrupt                                  */
  998.  
  999. void kbd_all_off(void);
  1000. /* turns all three lights off (NUM LOCK, CAPS LOCK, and SCROLL LOCK)        */
  1001.  
  1002. void kbd_all_on(void);
  1003. /* turns all three lights on (NUM LOCK, CAPS LOCK, and SCROLL LOCK)         */
  1004.  
  1005. void kbd_caps_off(void);               /* turns CAPS LOCK light off         */
  1006. void kbd_caps_on(void);                /* turns CAPS LOCK light on          */
  1007.  
  1008. char kbd_hit(void);
  1009. /* RETURNS: ASCII value of key if a key is ready to be retrieved
  1010.               (by getchr/getchre)
  1011.             0 if no key has been pressed                                    */
  1012.  
  1013. void kbd_insert_off(void);             /* turns INSERT on                   */
  1014. void kbd_insert_on(void);              /* turns INSERT off                  */
  1015.  
  1016. boolean kbd_is_all_on(void);
  1017. /* RETURNS: TRUE if all light on, FALSE if not                              */
  1018.  
  1019. boolean kbd_is_alt(void);
  1020. /* RETURNS: TRUE if either alt is depressed, FALSE if not                   */
  1021.  
  1022. boolean kbd_is_alt_left(void);
  1023. /* RETURNS: TRUE if left alt is depressed, FALSE if not                     */
  1024.  
  1025. boolean kbd_is_alt_left_only(void);
  1026. /* RETURNS: TRUE if only left alt is depressed, FALSE if not                */
  1027.  
  1028. boolean kbd_is_alt_right(void);
  1029. /* RETURNS: TRUE if right alt is depressed, FALSE if not                    */
  1030.  
  1031. boolean kbd_is_alt_right_only(void);
  1032. /* RETURNS: TRUE if only right alt is depressed, FALSE if not               */
  1033.  
  1034. boolean kbd_is_alt_only(void);
  1035. /* RETURNS: TRUE if only an alt is depressed, FALSE if not                  */
  1036.  
  1037. boolean kbd_is_caps_on(void);
  1038. /* RETURNS: TRUE if CAPS LOCK light on, FALSE if not                        */
  1039.  
  1040. boolean kbd_is_ctrl(void);
  1041. /* RETURNS: TRUE if either ctrl is depressed, FALSE if not                  */
  1042.  
  1043. boolean kbd_is_ctrl_left(void);
  1044. /* RETURNS: TRUE if left ctrl is depressed, FALSE if not                    */
  1045.  
  1046. boolean kbd_is_ctrl_left_only(void);
  1047. /* RETURNS: TRUE if only left ctrl is depressed, FALSE if not               */
  1048.  
  1049. boolean kbd_is_ctrl_right(void);
  1050. /* RETURNS: TRUE if right ctrl is depressed, FALSE if not                   */
  1051.  
  1052. boolean kbd_is_ctrl_right_only(void);
  1053. /* RETURNS: TRUE if only right ctrl is depressed, FALSE if not              */
  1054.  
  1055. boolean kbd_is_ctrl_only(void);
  1056. /* RETURNS: TRUE if only a ctrl is depressed, FALSE if not                  */
  1057.  
  1058. boolean kbd_is_insert_on(void);
  1059. /* RETURNS: TRUE if INSERT is on, FALSE if not                              */
  1060.  
  1061. boolean kbd_is_num_on(void);
  1062. /* RETURNS:TRUE if NUM LOCK light on, FALSE if not                          */
  1063.  
  1064. boolean kbd_is_scroll_on(void);
  1065. /* RETURNS: TRUE if SCROLL LOCK light on, FALSE if not                      */
  1066.  
  1067. boolean kbd_is_shift(void);
  1068. /* RETURNS: TRUE if either shift is depressed, FALSE if not                 */
  1069.  
  1070. boolean kbd_is_shift_left(void);
  1071. /* RETURNS: TRUE if left shift is depressed, FALSE if not                   */
  1072.  
  1073. boolean kbd_is_shift_left_only(void);
  1074. /* RETURNS: TRUE if only left shift is depressed, FALSE if not              */
  1075.  
  1076. boolean kbd_is_shift_right(void);
  1077. /* RETURNS: TRUE if right shift is depressed, FALSE if not                  */
  1078.  
  1079. boolean kbd_is_shift_right_only(void);
  1080. /* RETURNS: TRUE if only right shift is depressed, FALSE if not             */
  1081.  
  1082. boolean kbd_is_shift_only(void);
  1083. /* RETURNS: TRUE if a shift is depressed, FALSE if not                      */
  1084.  
  1085. void kbd_num_off(void);                /* turns NUM LOCK light off          */
  1086. void kbd_num_on(void);                 /* turns NUM LOCK light on           */
  1087.  
  1088. void kbd_scroll_off(void);             /* turns SCROLL LOCK light off       */
  1089. void kbd_scroll_on(void);              /* turns SCROLL LOCK light on        */
  1090.  
  1091. /* ------------------------------------------------------------------------ */
  1092. /* -------------------  LINKED LIST FUNCTION PROTOTYPES  ------------------ */
  1093.  
  1094. llist *lst_find(llist *node, llist *list);
  1095. /* RETURNS: "node" of linked "list"
  1096.             NULL if "node" not present in linked "list"                     */
  1097.  
  1098. llist_double *lst_free_double(llist_double *list);
  1099. /* deallocate a doubly-linked "list"
  1100.  * RETURNS: NULL                                                            */
  1101.  
  1102. llist_single *lst_free_single(llist_single *list);
  1103. /* deallocate a singly-linked "list"
  1104.  * RETURNS: NULL                                                            */
  1105.  
  1106. llist *lst_tail(llist *list);
  1107. /* RETURNS: tail of linked "list"                                           */
  1108.  
  1109. /* THE FOLLOWING TWO FUNCTIONS DO NOT YET WORK PROPERLY */
  1110. /*llist_double *lst_unlink_double(llist_double **head, llist_double *unlink);
  1111.  * unlink "unlink" from doubly linked list who's head is pointed to by "head"
  1112.  * RETURNS: next available node
  1113.  *          NULL if linked list is empty                                    */
  1114.  
  1115. /*llist_single *lst_unlink_single(llist_single **head, llist_single *unlink);
  1116.  * unlink "unlink" from singly linked list who's head is pointed to by "head"
  1117.  * RETURNS: next available node
  1118.  *          NULL if linked list is empty                                    */
  1119.  
  1120. /* ------------------------------------------------------------------------ */
  1121. /* ------------------  MATHEMATICAL FUNCTION PROTOTYPES  ------------------ */
  1122.  
  1123. double mth_findroot(double left, double right,
  1124.                     double tolerance, double (*f)(), double (*df)());
  1125. /* hybrid 1d Newton-Raphson/Regula Falsi root finder
  1126.  * input function f and its derivative df, an interval
  1127.  * left, right known to contain the root, and an error tolerance
  1128.  * Based on Blinn                                                           */
  1129.  
  1130. int mth_gcd(int u, int v);
  1131. /* binary greatest common divisor by Silver and Terzian.  See Knuth
  1132.  * both inputs must be >= 0                                                 */
  1133.  
  1134. byte max_byte(word nums, byte num1, ...);
  1135. /* RETURNS: greatest byte of a list of bytes                                */
  1136.  
  1137. int max_int(word nums, int num1, ...);
  1138. /* RETURNS: greatest integer of a list of integers                          */
  1139.  
  1140. shortint max_shortint(word nums, shortint num1, ...);
  1141. /* RETURNS: greatest integer of a list of short integers                    */
  1142.  
  1143. word max_word(word nums, word num1, ...);
  1144. /* RETURNS: greatest word of a list of words                                */
  1145.  
  1146. byte min_byte(word nums, byte num1, ...);
  1147. /* RETURNS: smallest byte of a list of bytes                                */
  1148.  
  1149. int min_int(word nums, int num1, ...);
  1150. /* RETURNS: smallest integers of a list of integers                         */
  1151.  
  1152. shortint min_shortint(word nums, shortint num1, ...);
  1153. /* RETURNS: smallest short integer of a list of short integers              */
  1154.  
  1155. word min_word(word nums, word num1, ...);
  1156. /* RETURNS: smallest word of a list of words                                */
  1157.  
  1158. double mth_newtonraphson(double (*f)(), double (*df)(), double x);
  1159. /* generic 1d Newton-Raphson step. f is function, df is derivative
  1160.  * x is current best guess for root location. Returns new estimate          */
  1161.  
  1162. int mth_roots_quadratic(double a, double b, double c, double *roots);
  1163. /* return roots of a*x^2 + b*x + c
  1164.  * stable algebra derived from Numerical Recipes by Press et al             */
  1165.  
  1166. double mth_regulafalsi(double (*f)(), double left, double right);
  1167. /* generic 1d regula-falsi step.  f is function to evaluate
  1168.  * interval known to contain root is given in left, right
  1169.  * returns new estimate                                                     */
  1170.  
  1171. /* ------------------------------------------------------------------------ */
  1172. /* ---------------  MATHEMATICAL MATRIX FUNCTION PROTOTYPES  -------------- */
  1173.  
  1174. matrix3 *m3_add(matrix3 *A, matrix3 *B, matrix3 *C);
  1175. /* C = A + B
  1176.  * RETURNS: C                                                               */
  1177.  
  1178. matrix3 *m3_copy(matrix3 *A);
  1179. /* RETURNS: copy of A                                                       */
  1180.  
  1181. matrix3 *m3_mul(matrix3 *A, matrix3 *B, matrix3 *C);
  1182. /* C = A * B
  1183.  * RETURNS: C                                                               */
  1184.  
  1185. matrix3 *m3_new(double *a[3][3]);
  1186. /* RETURNS: new 3x3 matrix initialized to a[3][3]                           */
  1187.  
  1188. matrix3 *m3_sub(matrix3 *A, matrix3 *B, matrix3 *C);
  1189. /* C = A - B
  1190.  * RETURNS: C                                                               */
  1191.  
  1192. matrix3 *m3_transpose(matrix3 *A, matrix3 *B);
  1193. /* B = transpose(A)
  1194.  * RETURNS: B                                                               */
  1195.  
  1196. matrix4 *m4_add(matrix4 *A, matrix4 *B, matrix4 *C);
  1197. /* C = A + B
  1198.  * RETURNS: C                                                               */
  1199.  
  1200. matrix4 *m4_copy(matrix4 *A);
  1201. /* RETURNS: copy of A                                                       */
  1202.  
  1203. matrix4 *m4_mul(matrix4 *A, matrix4 *B, matrix4 *C);
  1204. /* C = A * B
  1205.  * RETURNS: C                                                               */
  1206.  
  1207. matrix4 *m4_new(double *a[4][4]);
  1208. /* RETURNS: new 4x4 matrix initialized to a[4][4]                           */
  1209.  
  1210. matrix4 *m4_sub(matrix4 *A, matrix4 *B, matrix4 *C);
  1211. /* C = A - B
  1212.  * RETURNS: C                                                               */
  1213.  
  1214. matrix4 *m4_transpose(matrix4 *A, matrix4 *B);
  1215. /* B = transpose(A)
  1216.  * RETURNS: B                                                               */
  1217.  
  1218. /* ------------------------------------------------------------------------ */
  1219. /* ---------------  MATHEMATICAL VECTOR FUNCTION PROTOTYPES  -------------- */
  1220.  
  1221. vector2 *v2_add(vector2 *u, vector2 *v, vector2 *w);
  1222. /* w = u + v
  1223.  * RETURNS: w                                                               */
  1224.  
  1225. vector2 *v2_combine(vector2 *u, double c1,
  1226.                     vector2 *v, double c2, vector2 *w);
  1227. /* w = c1(u) + c2(v)
  1228.  * RETURNS: w                                                               */
  1229.  
  1230. vector2 *v2_copy(vector2 *v);
  1231. /* RETURNS: copy of u                                                       */
  1232.  
  1233. double v2_dot(vector2 *u, vector2 *v);
  1234. /* w = u dot v
  1235.  * RETURNS: w                                                               */
  1236.  
  1237. double v2_len(vector2 *v);
  1238. /* RETURNS: magnitude of v                                                  */
  1239.  
  1240. double v2_len_sqr(vector2 *v);
  1241. /* RETURNS: magnitude of v squared                                          */
  1242.  
  1243. vector2 *v2_lerp(vector2 *lo, vector2 *hi, double alpha, vector2 *w);
  1244. /* w = linear interpolation between lo and hi by amount alpha
  1245.  * RETURNS: w                                                               */
  1246.  
  1247. vector2 *v2_mul(vector2 *u, vector2 *v, vector2 *w);
  1248. /* w = u * v (multiplication component-wise)
  1249.  * RETURNS: w                                                               */
  1250.  
  1251. point2 *v2_mul_by_proj(point2 *p, matrix3 *A);
  1252. /* RETURNS: transformed point p * projection matrix m                       */
  1253.  
  1254. vector2 *v2_neg(vector2 *v);
  1255. /* v is negated
  1256.  * RETURNS: v                                                               */
  1257.  
  1258. vector2 *v2_new(double x, double y);
  1259. /* RETURNS: new 2D vector initialized to (x,y)                              */
  1260.  
  1261. vector2 *v2_norm(vector2 *v);
  1262. /* v is normalized (becomes unit length)
  1263.  * RETURNS: v                                                               */
  1264.  
  1265. vector2 *v2_ortho(vector2 *u, vector2 *v);
  1266. /* u = some orthogonal vector to v
  1267.  * RETURNS: u                                                               */
  1268.  
  1269. vector2 *v2_scale(vector2 *v, double newlen);
  1270. /* v is scaled to length newlen
  1271.  * RETURNS: v                                                               */
  1272.  
  1273. double v2_seg_len(point2 *p, point2 *q);
  1274. /* RETURNS: length of line segment pq                                       */
  1275.  
  1276. vector2 *v2_sub(vector2 *u, vector2 *v, vector2 *w);
  1277. /* w = u - v
  1278.  * RETURNS: w                                                               */
  1279.  
  1280. vector3 *v3_add(vector3 *u, vector3 *v, vector3 *w);
  1281. /* w = u + v
  1282.  * RETURNS: w                                                               */
  1283.  
  1284. vector3 *v3_combine(vector3 *u, double c1,
  1285.                     vector3 *v, double c2, vector3 *w);
  1286. /* w = c1(u) + c2(v)
  1287.  * RETURNS: w                                                               */
  1288.  
  1289. vector3 *v3_copy(vector3 *v);
  1290. /* RETURNS: copy of u                                                       */
  1291.  
  1292. vector3 *v3_cross(vector3 *u, vector3 *v, vector3 *w);
  1293. /* w = u cross v
  1294.  * RETURNS: w                                                               */
  1295.  
  1296. double v3_dot(vector3 *u, vector3 *v);
  1297. /* w = u dot v
  1298.  * RETURNS: w                                                               */
  1299.  
  1300. double v3_len(vector3 *v);
  1301. /* RETURNS: magnitude of v                                                  */
  1302.  
  1303. double v3_len_sqr(vector3 *v);
  1304. /* RETURNS: magnitude of v squared                                          */
  1305.  
  1306. vector3 *v3_lerp(vector3 *lo, vector3 *hi, double alpha, vector3 *w);
  1307. /* w = linear interpolation between lo and hi by amount alpha
  1308.  * RETURNS: w                                                               */
  1309.  
  1310. vector3 *v3_mul(vector3 *u, vector3 *v, vector3 *w);
  1311. /* w = u * v (multiplication component-wise)
  1312.  * RETURNS: w                                                               */
  1313.  
  1314. point3 *v3_mul_by_matrix(point3 *p, matrix3 *A, point3 *q);
  1315. /* q = p * A
  1316.  * RETURNS: transformed point q                                             */
  1317.  
  1318. point3 *v3_mul_by_proj(point3 *p, matrix4 *A);
  1319. /* RETURNS: transformed point p * projection matrix A                       */
  1320.  
  1321. vector3 *v3_neg(vector3 *v);
  1322. /* v is negated
  1323.  * RETURNS: v                                                               */
  1324.  
  1325. vector3 *v3_new(double x, double y, double z);
  1326. /* RETURNS: new 3D vector initialized to (x,y,z)                            */
  1327.  
  1328. vector3 *v3_norm(vector3 *v);
  1329. /* v is normalized (becomes unit length)
  1330.  * RETURNS: v                                                               */
  1331.  
  1332. vector3 *v3_scale(vector3 *v, double newlen);
  1333. /* v is scaled to length newlen
  1334.  * RETURNS: v                                                               */
  1335.  
  1336. double v3_seg_len(point3 *p, point3 *q);
  1337. /* RETURNS: length of line segment pq                                       */
  1338.  
  1339. vector3 *v3_sub(vector3 *u, vector3 *v, vector3 *w);
  1340. /* w = u - v
  1341.  * RETURNS: w                                                               */
  1342.  
  1343. /* ------------------------------------------------------------------------ */
  1344. /* ------------------  MISCELLANEOUS FUNCTION PROTOTYPES  ----------------- */
  1345.  
  1346. void beep(void);
  1347. /* beeps speaker                                                            */
  1348.  
  1349. byte bestlib_init(byte mode, boolean mouse);
  1350. /* initializes THE BEST LIBRARY
  1351.  * sets "blink" = TRUE and "txt_cur_move" = TRUE
  1352.  * calls "msec" and "txt_mem(TEXTSAVE, NULL)"
  1353.  * if originally in a text mode, fills global structure "cursor"
  1354.  * sets the video mode to "mode" [see video_set for details]
  1355.  * if "mode" = FALSE, does not change video mode
  1356.  * if "mouse" = TRUE, initializes the mouse to video mode "mode"
  1357.  * if "mouse = FALSE, does not initialize mouse
  1358.  * RETURNS: previous video mode if video mode was changed (if not,
  1359.             current video mode)                                             */
  1360.  
  1361. void boot(word how);
  1362. /* "how" = WARM, warm boot; "how" = COLD, cold boot                         */
  1363.  
  1364. char *dos_shell(void);
  1365. /* shells to DOS, returning on "EXIT"
  1366.  * RETURNS: NULL if successful, or a pointer to a string saying error       */
  1367.  
  1368. void msec(int delaytime);
  1369. /* delays computer for "delaytime" milliseconds
  1370.  * first call initializes itself to computer                                */
  1371.  
  1372. void sound_off(void);
  1373. /* stops any sound from the speaker                                         */
  1374.  
  1375. boolean stopw(byte index, word delaytime);
  1376. /* "index" refers to a stopwatch and must be between 0-99
  1377.  * "delaytime" is number of clock ticks to set stopwatch to
  1378.  * if called with "delaytime" = 0,
  1379.  *   RETURNS: TRUE  if finished
  1380.               FALSE if not                                                  */
  1381.  
  1382. byte video_get(void);
  1383. /* RETURNS: current video mode                                              */
  1384.  
  1385. void video_restore(byte mode);
  1386. /* restores video to "mode"
  1387.  * if "mode" is a text mode, restores video memory, cursor position and shape,
  1388.    turns on cursor, and enables blinking characters                         */
  1389.  
  1390. void video_set(byte mode);
  1391. /* "mode" represents a video mode: [value] - manually specified video mode
  1392.                                    TEXT    - text mode if not already in one
  1393.                                    TEXT25  - 25-line text mode
  1394.                                    TEXT50  - 50-line text mode
  1395.                                    TEXT25F - forced 25-line text mode
  1396.                                    TEXT50F - forced 50-line text mode
  1397.                                    VGA16   - 640x480x16 graphics mode
  1398.                                    VGA256  - 320x200x256 graphics mode
  1399.  * NOTE  re-initialize mouse driver by "ms_init" to new video mode          */
  1400.  
  1401. /* ------------------------------------------------------------------------ */
  1402. /* ----------------------  MOUSE FUNCTION PROTOTYPES  --------------------- */
  1403.  
  1404. void ms_get(int *x, int *y);
  1405. /* stores mouse abscissa in "x" and mouse ordinate in "y"
  1406.  * if mouse is in text mode, stores byte values (can be byte *x, byte *y)
  1407.  * if "y" = NULL, "x" assumed to be "int *xy" (or byte *xy if text mode)    */
  1408.  
  1409. int ms_getx(void);
  1410. /* RETURNS: mouse abscissa
  1411.  * if mouse is in text mode, RETURNS: byte value                            */
  1412.  
  1413. int ms_gety(void);
  1414. /* RETURNS: mouse ordinate
  1415.  * if mouse is in text mode, RETURNS: byte value                            */
  1416.  
  1417. void ms_hide(void);
  1418. /* hides mouse cursor                                                       */
  1419.  
  1420. boolean ms_init(byte mode);
  1421. /* initialize mouse for video mode "mode"
  1422.                                        TEXT25 - 25-line text mode
  1423.                                        TEXT50 - 50-line text mode
  1424.                                        VGA16  - 640x480x16 graphics mode
  1425.                                        VGA256 - 320x200x256 graphics mode
  1426.  * initializes "mousepresent" to return value
  1427.  * initializes structure "msdata" with default values
  1428.  * centers mouse cursor on screen and hides it (use "ms_show" to see it)
  1429.  * sets maximum abscissa and ordinate of mouse cursor to screen size
  1430.  * RETURNS: TRUE if successful or FALSE if no mouse driver present          */
  1431.  
  1432. boolean ms_kill(void);
  1433. /* completely disables mouse driver;
  1434.  * RETURNS: TRUE is successful or FALSE is failed                           */
  1435.  
  1436. void ms_range(int minx, int miny, int maxx, int maxy);
  1437. /* new mosue movement range is bounded by "minx","miny" and "maxx","maxy"
  1438.  * if "minx" = MIN, sets minimum abscissa to screen minimum
  1439.  * if "maxx" = MAX, sets maximum abscissa to screen maximum
  1440.  * if "miny" = MIN, sets minimum ordinate to screen minimum
  1441.  * if "maxy" = MAX, sets maximum ordinate to screen maximum                 */
  1442.  
  1443. void ms_set(int x, int y);
  1444. /* position mouse cursor at "x","y"
  1445.  * if "x" = MEM, the "mousedata.npos[0]" is used
  1446.  * if "y" = MEM, the "mousedata.npos[1]" is used
  1447.  * if values are supplied for either "x" or "y", those are stored into
  1448.    "mousedata.npos[0]" or "mousedata.npos[1]", respectively                 */
  1449.  
  1450. int ms_setx(int x);
  1451. /* set mouse cursor abscissa to "x"
  1452.  * if "x" = MEM, the "mousedata.npos[0]" is used
  1453.  * if a value is supplied for "x", it is stored into "mousedata.npos[0]"
  1454.  * RETURNS: mouse ordinate                                                  */
  1455.  
  1456. int ms_sety(int y);
  1457. /* set mouse cursor ordinate to "y"
  1458.  * if "x" = MEM, the "mousedata.npos[1]" is used
  1459.  * if a value is supplied for "y", it is stored into "mousedata.npos[1]"
  1460.  * RETURNS: mouse abscissa                                                  */
  1461.  
  1462. char ms_shape_get(byte *fgclr, byte *bgclr, char *ch);
  1463. /* reads in the current text mouse "bgclr","fgclr", and "ch"
  1464.  * RETURNS: ASCII character of mouse                                        */
  1465.  
  1466. void ms_shape_set(byte fgclr, byte bgclr, char ch);
  1467. /* changes the text mouse cursor to ASCII character "ch"
  1468.  * "fgclr"/"bgclr" = NO if no foreground/background color modification
  1469.  * "ch" = NO if no character modification                                   */
  1470.  
  1471. void ms_show(void);
  1472. /* displays mouse cursor                                                    */
  1473.  
  1474. void ms_stat(void);
  1475. /* updates all "mousedata" information except pos[] and but[]               */
  1476.  
  1477. /* ------------------------------------------------------------------------ */
  1478. /* ---------------------  STRING FUNCTION PROTOTYPES  --------------------- */
  1479.  
  1480. boolean is_number_dec(char *str);
  1481. /* RETURNS: TRUE  if "str" is a decimal number
  1482.             FALSE if not                                                    */
  1483.  
  1484. boolean is_number_hex(char *str);
  1485. /* RETURNS: TRUE if "str" is a hexadecimal number, FALSE if not
  1486.             FALSE if not                                                    */
  1487.  
  1488. void mem_copy(void *destination, void *source, word bytes);
  1489. /* copy "bytes" bytes from "source" into "destination"                      */
  1490.  
  1491. word scan_byte(char *start, char compare, word count, boolean direction);
  1492. /* checks if one-byte value "compare" is present in "start"
  1493.  * checks "count" bytes (if NULL, search to end of "start")
  1494.  * search "direction": FORWARD or BACKWARD
  1495.  * RETURNS: offset + 1 of first character matching "compare"
  1496.       else FALSE      if no match found or "start" is not a string          */
  1497.  
  1498. word scan_byte_not(char *start, char compare, word count, boolean direction);
  1499. /* checks if any one-byte value other than "compare" is present in "start"
  1500.  * checks "count" bytes (if NULL, search to end of "start")
  1501.  * search "direction": FORWARD or BACKWARD
  1502.  * RETURNS: offset + 1 of first character not matching "compare"
  1503.       else FALSE      if only "compare" present (no other characters)       */
  1504.  
  1505. word scan_bytes(char *start, char compare[], word count, boolean direction);
  1506. /* checks if any one of the characters in "compare" (which must be a NULL-
  1507.    terminated string) are present in "start"
  1508.  * checks "count" bytes (if NULL, search to end of "start")
  1509.  * search "direction": FORWARD or BACKWARD
  1510.  * RETURNS: offset + 1 of first character matching one of "compare"
  1511.       else FALSE      if no match found or "start" is not a string          */
  1512.  
  1513. word scan_bytes_not(char *start, char compare[],
  1514.                     word count, boolean direction);
  1515. /* checks if any characters other than those in "compare" (which must be
  1516.    NULL-terminated) are present in "start"
  1517.  * checks "count" bytes (if NULL, search to end of "start")
  1518.  * search "direction": FORWARD or BACKWARD
  1519.  * RETURNS: offset + 1 of first character not matching "compare"
  1520.       else FALSE      if only "compare" present (no other characters)       */
  1521.  
  1522. word scan_str(char *start, char *compare, word count, boolean direction);
  1523. /* checks if "compare" is present in "start"
  1524.  * checks "count" bytes (if NULL, search to end of "start")
  1525.  * search "direction": FORWARD or BACKWARD
  1526.  * RETURNS: offset + 1 of first string matching "compare"
  1527.       else FALSE      if no match found or if either "compare" or
  1528.                       "start" are not strings                               */
  1529.  
  1530. word scan_str_not(char *start, char *compare, word count, boolean direction);
  1531. /* checks if any string other than "compare" is present in "start"
  1532.  * checks "count" bytes (if NULL, search to end of "start")
  1533.  * search "direction": FORWARD or BACKWARD
  1534.  * RETURNS: offset + 1 of first string not matching "compare"
  1535.       else FALSE      if no match found or if either "compare" or
  1536.                       "start" are not strings                               */
  1537.  
  1538. word scan_strs(char *start, char *compare[], word count, boolean direction);
  1539. /* checks if any one of the strings in "compare" ("compare" must be
  1540.    NULL-terminated) are present in "start"
  1541.  * checks "count" bytes (if NULL, search to end of "start")
  1542.  * search "direction": FORWARD or BACKWARD
  1543.  * RETURNS: offset + 1 of first string matching "compare"
  1544.       else FALSE      if no match found or if either "compare" or
  1545.                       "start" are not strings                               */
  1546.  
  1547. word scan_strs_not(char *start, char *compare[],
  1548.                    word count, boolean direction);
  1549. /* checks if any string other than those in "compare" ("compare" must be
  1550.    NULL-terminated) are present in "start"
  1551.  * checks "count" bytes (if NULL, search to end of "start")
  1552.  * search "direction": FORWARD or BACKWARD
  1553.  * RETURNS: offset + 1 of first string not matching "compare"
  1554.       else FALSE      if no match found or if either "compare" or
  1555.                       "start" are not strings                               */
  1556.  
  1557. word scan_word(word *start, word compare, word count, boolean direction);
  1558. /* checks if word "compare" is present in "start"
  1559.  * checks "count" words
  1560.  * search "direction": FORWARD or BACKWARD
  1561.  * RETURNS: offset + 1 of first integer matching "compare" or
  1562.            FALSE      if no match found or if "count" = 0                   */
  1563.  
  1564. word scan_word_not(word *start, word compare, word count, boolean direction);
  1565. /* checks if any integers other than "compare" are present in
  1566.    "start"
  1567.  * checks "count" words
  1568.  * search "direction": FORWARD or BACKWARD
  1569.  * RETURNS: offset + 1 of first integer not matching "compare"
  1570.       else FALSE      if only "compare" is present (no other integers)      */
  1571.  
  1572. word scan_words(word *start, word compare[], word count, boolean direction);
  1573. /* checks if any one of the integers in "compare" ("compare" must be
  1574.    NULL-terminated) are present in "start"
  1575.  * checks "count" words
  1576.  * search "direction": FORWARD or BACKWARD
  1577.  * RETURNS: offset + 1 of first integer matching "compare" or
  1578.            FALSE      if no match found or if "count" = 0                   */
  1579.  
  1580. word scan_words_not(word *start, word compare[],
  1581.                     word count, boolean direction);
  1582. /* checks if any integer other than those in "compare" ("compare" must
  1583.    be NULL-terminated) are present in "start"
  1584.  * checks "count" words
  1585.  * search "direction": FORWARD or BACKWARD
  1586.  * RETURNS: offset + 1 of first integer not matching "compare"
  1587.       else FALSE      if only "compare" is present (no other integers)      */
  1588.  
  1589. int sign(int number);
  1590. /* RETURNS: sign of "number"                                                */
  1591.  
  1592. void str_case_down(char *str);
  1593. /* converts all characters in "str" to lowercase                            */
  1594.  
  1595. void str_case_down_pr(printdata *prdata);
  1596. /* converts all characters in "prdata.string" to lowercase                  */
  1597.  
  1598. void str_case_flip(char *str);
  1599. /* converts all characters in "str" to opposite case                        */
  1600.  
  1601. void str_case_flip_pr(printdata *prdata);
  1602. /* converts all characters in "prdata.string" to opposite case              */
  1603.  
  1604. void str_case_up(char *str);
  1605. /* converts all characters in string "str" to uppercase                     */
  1606.  
  1607. void str_case_up_pr(printdata *prdata);
  1608. /* converts all characters in "prdata.string" to uppercase                  */
  1609.  
  1610. int str_cmp(char *str1, char *str2);
  1611. /* compares "str1" to "str2"
  1612.  * RETURNS: +1 if "str1" is alphabetically greater than "str2"
  1613.  * RETURNS:  0 if "str1" and "str2" are same
  1614.  * RETURNS: -1 if "str1" is alphabetically less than "str2"                 */
  1615.  
  1616. word str_copy(char *destination, char *source);
  1617. /* copies string "source" into "destination" (including NULL terminator)
  1618.  * RETURNS: length of string "source"                                       */
  1619.  
  1620. void str_del_byte(char *start, char del, word count);
  1621. /* deletes all occurrences of "del" from "start", searching "count" bytes
  1622.  * if "count" = NULL, search to end of "start"                              */
  1623.  
  1624. void str_del_bytes(char *start, word count);
  1625. /* deletes "count" bytes from "start"                                       */
  1626.  
  1627. void str_del_str(char *start, char *del, word count);
  1628. /* deletes all occurrences of "del" from "start", searching "count" bytes
  1629.  * if "count" = NULL, search to end of "start"                              */
  1630.  
  1631. void str_del_word(word *start, word del, word count);
  1632. /* deletes all occurrences of "del" from "start", searching "count" bytes   */
  1633.  
  1634. void str_del_words(word *start, word count);
  1635. /* deletes "count" words from "start"                                       */
  1636.  
  1637. void str_fill_byte(char *destination, char source, word count);
  1638. /* Fills "destination" with "count" byte-values "source"                    */
  1639.  
  1640. void str_fill_str(char *destination, char *source, word count);
  1641. /* Fills "destination" with "count" strings "source"                        */
  1642.  
  1643. void str_fill_word(word *destination, word source, word count);
  1644. /* Fills "destination" with "count" word-values "source"                    */
  1645.  
  1646. void str_inc(char *str);                   /* increments ASCII number "str" */
  1647.  
  1648. void str_ins_byte(char *start, char insert, word count);
  1649. /* inserts "count" "insert"s into string "start"                            */
  1650.  
  1651. void str_ins_str(char *start, char *insert, word count);
  1652. /* inserts "count" "insert"s into string "start"                            */
  1653.  
  1654. void str_ins_word(word *start, word insert, word count);
  1655. /* inserts "count" "insert"s into word array "start"                        */
  1656.  
  1657. word str_len(char *str);
  1658. /* RETURNS: length of "str"                                                 */
  1659.  
  1660. word str_len_pr(printdata *prdata);
  1661. /* RETURNS: length of "prdata.string"                                       */
  1662.  
  1663. char *str_next_str(char *str);
  1664. /* read next string from "str" (a string can consist of alphanumeric
  1665.    characters, hyphens, apostrophes, or text surrounded in quotes, like
  1666.    "It is: 04/12/94" -- nothing else)
  1667.  * RETURNS: pointer to next word
  1668.  *          NULL if no word was found (passed in a NULL string)             */
  1669.  
  1670. char *str_next_word(char *str);
  1671. /* read next word from "str" (a word can consist of alphabet letters,
  1672.    hyphens, or apostrophes -- nothing else)
  1673.  * RETURNS: pointer to next word
  1674.  *          NULL if no word was found (passed in a NULL string)             */
  1675.  
  1676. void str_rep_byte_byte(char *start, char search,
  1677.                        char replace, word count, boolean direction);
  1678. /* search "start" "count" bytes for "search" and replaces all occurrences
  1679.    of it with "replace"
  1680.  * if "count" = NULL, search to end of "start"  ONLY WITH DIRECTION: FORWARD
  1681.  * search in "direction": FORWARD or BACKWARD
  1682.  * WARNING: IF "count" = NULL AND "direction" = BACKWARD, WILL SEARCH AND
  1683.    REPLACE BEYOND BEGINNING OF STRING "start" -- DO NOT DO THIS!!           */
  1684.  
  1685. void str_rep_byte_str(char *start, char search,
  1686.                       char *replace, word count, boolean direction);
  1687. /* search "start" "count" bytes for "search" and replaces all occurrences
  1688.    of it with "replace"
  1689.  * if "count" = NULL, search to end of "start"  ONLY WITH DIRECTION: FORWARD
  1690.  * search in "direction": FORWARD or BACKWARD
  1691.  * WARNING: IF "count" = NULL AND "direction" = BACKWARD, WILL SEARCH AND
  1692.    REPLACE BEYOND BEGINNING OF STRING "start" -- DO NOT DO THIS!!           */
  1693.  
  1694. void str_rep_byte_word(char *start, char search,
  1695.                        word replace, word count, boolean direction);
  1696. /* search "start" "count" bytes for "search" and replaces all occurrences
  1697.    of it with "replace"
  1698.  * if "count" = NULL, search to end of "start"  ONLY WITH DIRECTION: FORWARD
  1699.  * search in "direction": FORWARD or BACKWARD
  1700.  * WARNING: IF "count" = NULL AND "direction" = BACKWARD, WILL SEARCH AND
  1701.    REPLACE BEYOND BEGINNING OF STRING "start" -- DO NOT DO THIS!!           */
  1702.  
  1703. void str_rep_str_byte(char *start, char *search,
  1704.                       char replace, word count, boolean direction);
  1705. /* search "start" "count" bytes for "search" and replaces all occurrences
  1706.    of it with "replace"
  1707.  * if "count" = NULL, search to end of "start"  ONLY WITH DIRECTION: FORWARD
  1708.  * search in "direction": FORWARD or BACKWARD
  1709.  * WARNING: IF "count" = NULL AND "direction" = BACKWARD, WILL SEARCH AND
  1710.    REPLACE BEYOND BEGINNING OF STRING "start" -- DO NOT DO THIS!!           */
  1711.  
  1712. void str_rep_str_str(char *start, char *search,
  1713.                      char *replace, word count, boolean direction);
  1714. /* search "start" "count" bytes for "search" and replaces all occurrences
  1715.    of it with "replace"
  1716.  * if "count" = NULL, search to end of "start"  ONLY WITH DIRECTION: FORWARD
  1717.  * search in "direction": FORWARD or BACKWARD
  1718.  * WARNING: IF "count" = NULL AND "direction" = BACKWARD, WILL SEARCH AND
  1719.    REPLACE BEYOND BEGINNING OF STRING "start" -- DO NOT DO THIS!!           */
  1720.  
  1721. void str_rep_word_byte(word *start, word search,
  1722.                        char replace, word count, boolean direction);
  1723. /* search "start" "count" bytes for "search" and replaces all occurrences
  1724.    of it with "replace"
  1725.  * search in "direction": FORWARD or BACKWARD                               */
  1726.  
  1727. void str_rep_word_word(word *start, word search,
  1728.                        word replace, word count, boolean direction);
  1729. /* search "start" "count" bytes for "search" and replaces all occurrences
  1730.    of it with "replace"
  1731.  * search in "direction": FORWARD or BACKWARD                               */
  1732.  
  1733. char str_right(char *str, word number);
  1734. /* RETURNS: char "number" from string "str", counting from end of string    */
  1735.  
  1736. char str_right_pr(printdata *prdata, word number);
  1737. /* RETURNS: char "number" from string "prdata.string", counting from end of
  1738.             string                                                          */
  1739.  
  1740. /* ------------------------------------------------------------------------ */
  1741. /* ----------------  STRING CHARACTER FUNCTION PROTOTYPES  ---------------- */
  1742.  
  1743. char case_down(char ch);
  1744. /* RETURNS: "ch" in lowercase                                               */
  1745.  
  1746. char case_down_ptr(char *ch);
  1747. /* RETURNS: "ch" in lowercase (also modifies "ch")                          */
  1748.  
  1749. char case_flip(char ch);
  1750. /* RETURNS: "ch" in opposite case                                           */
  1751.  
  1752. char case_flip_ptr(char *ch);
  1753. /* RETURNS: "ch" in opposite case (also modifies "ch")                      */
  1754.  
  1755. char case_up(char ch);
  1756. /* RETURNS: "ch" in uppercase                                               */
  1757.  
  1758. char case_up_ptr(char *ch);
  1759. /* RETURNS: "ch" in uppercase (also modifies "ch")                          */
  1760.  
  1761. boolean is_alpha(char ch);
  1762. /* RETURNS: TRUE if "ch" is an alphabet letter, FALSE if not
  1763.             FALSE if not                                                    */
  1764.  
  1765. boolean is_alpha_down(char ch);
  1766. /* RETURNS: TRUE if "ch" is a lowercase alphabet letter, FALSE if not
  1767.             FALSE if not                                                    */
  1768.  
  1769. boolean is_alpha_up(char ch);
  1770. /* RETURNS: TRUE if "ch" is an uppercase alphabet letter, FALSE if not
  1771.             FALSE if not                                                    */
  1772.  
  1773. boolean is_alphanum(char ch);
  1774. /* RETURNS: TRUE if "ch" is an alphanumeric character, FALSE if not
  1775.             FALSE if not                                                    */
  1776.  
  1777. boolean is_ascii(char ch);
  1778. /* RETURNS: TRUE if "ch" is a standard ASCII character, FALSE if not
  1779.             FALSE if not                                                    */
  1780.  
  1781. boolean is_case_down(char ch);
  1782. /* RETURNS: TRUE if "ch" is lowercase, FALSE if not
  1783.             FALSE if not                                                    */
  1784.  
  1785. boolean is_case_up(char ch);
  1786. /* RETURNS: TRUE if "ch" is uppercase, FALSE if not
  1787.             FALSE if not                                                    */
  1788.  
  1789. boolean is_ctrlchar(char ch);
  1790. /* RETURNS: TRUE if "ch" is a control character (0-31 or 127), FALSE if not
  1791.             FALSE if not                                                    */
  1792.  
  1793. boolean is_digit_dec(char ch);
  1794. /* RETURNS: TRUE if "ch" is a digit, FALSE if not
  1795.             FALSE if not                                                    */
  1796.  
  1797. boolean is_digit_hex(char ch);
  1798. /* RETURNS: TRUE if "ch" is a hexadecimal digit, FALSE if not
  1799.             FALSE if not                                                    */
  1800.  
  1801. boolean is_greek(char ch);
  1802. /* RETURNS: TRUE if "ch" is a greek letter, FALSE if not
  1803.             FALSE if not                                                    */
  1804.  
  1805. boolean is_letter(char ch);
  1806. /* RETURNS: TRUE  if "ch" is an alphabet letter, an apostrophe, or a hyphen
  1807.             FALSE if not                                                    */
  1808.  
  1809. boolean is_letternum(char ch);
  1810. /* RETURNS: TRUE  if "ch" is an alphanumeric letter, an apostrophe, or a
  1811.                   hyphen
  1812.             FALSE if not                                                    */
  1813.  
  1814. boolean is_print(char ch);
  1815. /* RETURNS: TRUE  if "ch" is a printable character (has ASCII symbol)
  1816.             FALSE if not                                                    */
  1817.  
  1818. boolean is_punc(char ch);
  1819. /* RETURNS: TRUE if "ch" is a punctuation character, FALSE if not
  1820.             FALSE if not                                                    */
  1821.  
  1822. /* ------------------------------------------------------------------------ */
  1823. /* ----------------  STRING CONVERSION FUNCTION PROTOTYPES  --------------- */
  1824.  
  1825. char *con_bool_to_str(boolean bool);
  1826. /* convert boolean FALSE or TRUE into a string
  1827.  * RETURNS: "TRUE"  if "bool" = TRUE
  1828.  *          "FALSE" if "bool" = FALSE                                       */
  1829.  
  1830. char *con_color_to_str(byte color);
  1831. /* convert "color" into its string color name
  1832.  * RETURNS: string representation of color
  1833.  *          NULL if "color" is not a valid color                            */
  1834.  
  1835. shortint con_str_to_bool(char *str);
  1836. /* convert "str" into FALSE or TRUE
  1837.  * RETURNS: TRUE  if "str" = "TRUE"
  1838.  *          FALSE if "str" = "FALSE"
  1839.  *          -1    if "str" is not a valid boolean word                      */
  1840.  
  1841. shortint con_str_to_color(char *str);
  1842. /* convert "str" into its color equivalent
  1843.  * RETURNS: color value
  1844.  *          -1 if "str" is not a valid color                                */
  1845.  
  1846.  
  1847. /* ------------------------------------------------------------------------ */
  1848. /* --------------------  TEXT MODE FUNCTION PROTOTYPES  ------------------- */
  1849.  
  1850. void txt_ascii_get(word number, byte codes[]);
  1851. /* reads "number" characters into "codes"
  1852.  * see ASCII GRAPHIC DEFINITIONS for details on structure of "codes"        */
  1853.  
  1854. void txt_ascii_set(word number, byte codes[]);
  1855. /* sets "number" characters using data from "codes"
  1856.  * see ASCII GRAPHIC DEFINITIONS for details on structure of "codes"        */
  1857.  
  1858. void txt_blink(int what);
  1859. /* if "what" = TRUE,  blinking characters
  1860.              = FALSE, 16 background colors                                  */
  1861.  
  1862. byte txt_char_height(void);
  1863. /* RETURNS: height of text mode characters (in pixels/scan lines)           */
  1864.  
  1865. byte txt_char_length(void);
  1866. /* RETURNS: length of text mode characters (in pixels)                      */
  1867.  
  1868. void txt_cls(void);
  1869. /* clears the screen                                                        */
  1870.  
  1871. void txt_erase(byte x, byte y, byte length, byte height);
  1872. /* overwrites the region with corner at "x","y", x-length "length", and
  1873.    y-height "height" with spaces                                            */
  1874.  
  1875. void txt_erase_col(byte col);
  1876. /* overwrites "col" with spaces                                             */
  1877.  
  1878. void txt_erase_row(byte row);
  1879. /* overwrites "row" with spaces                                             */
  1880.  
  1881. void txt_fill_area(byte x, byte y, filldata *fidata);
  1882. /* fills screen according to structure "fidata"
  1883.  * the filling begins at corner "x","y"
  1884.  * if "x" = MEM, "fidata.x" is used
  1885.  * if "y" = MEM, "fidata.y" is used                                         */
  1886.  
  1887. char txt_fill_col(byte col, byte fgclr, byte bgclr, char *str);
  1888. /* prints string "str" in fgcolor "fgclr" and bgcolor "bgclr" at "col",0
  1889.    down the screen
  1890.  * if "fgclr" = NO, foreground is not modified
  1891.  * if "bgclr" = NO, background is not modified
  1892.  * if "str" = NULL, no string is printed
  1893.  * RETURNS: ASCII value of first character overwritten                      */
  1894.  
  1895. char txt_fill_row(byte row, byte fgclr, byte bgclr, char *str);
  1896. /* prints string "str" in fgcolor "fgclr" and bgcolor "bgclr" at 0,"row"
  1897.    across the screen
  1898.  * if "fgclr" = NO, foreground is not modified
  1899.  * if "bgclr" = NO, background is not modified
  1900.  * if "str" = NULL, no string is printed
  1901.  * RETURNS: ASCII value of first character overwritten                      */
  1902.  
  1903. word txt_flood(byte fgclr, byte bgclr, char *str);
  1904. /* floods screen with string "str" in "fgclr","bgclr"
  1905.  * if "fgclr" = NO, foreground color is not modified
  1906.  * if "bgclr" = NO, background color is not modified
  1907.  * if "str" = NULL, no string is written
  1908.  * RETURNS: length of "str"                                                 */
  1909.  
  1910. word txt_get_abs(void);
  1911. /* RETURNS: offset of text page                                             */
  1912.  
  1913. byte txt_get_act(void);
  1914. /* RETURNS: active text page                                                */
  1915.  
  1916. byte txt_get_vis(void);
  1917. /* RETURNS: visual text page                                                */
  1918.  
  1919. byte txt_last(void);
  1920. /* RETURNS: last text page number                                           */
  1921.  
  1922. void txt_mem(byte what, textimagedata *timage);
  1923. /* if "what" = TEXTSHOW - restores text memory
  1924.              = TEXTSAVE - stores text memory
  1925.  * storage area "timage" is used (use "txt_chrattrs_need" to get memory
  1926.    requirements for storing an 80x25 or 80x50 screen)
  1927.  * if "timage" = NULL, one built-in storage area is used                    */
  1928.  
  1929. word txt_print(byte x, byte y, printdata *prdata);
  1930. /* prints according to structure "prdata"
  1931.  * the printing begins at "x","y"
  1932.  * if "x" = MEM, "prdata.x" is used
  1933.  * if "y" = MEM, "prdata.y" is used
  1934.  * RETURNS: length of "prdata.string"                                       */
  1935.  
  1936. byte txt_rows(void);
  1937. /* RETURNS: [number of rows]-1 in current text page                         */
  1938.  
  1939. void txt_scroll(int columns, int rows);
  1940. /* smoothly scrolls screen "columns" and "rows" -- negatives apply          */
  1941.  
  1942. void txt_scroll_fast(shortint columns, shortint rows);
  1943. /* quickly smoothly scrolls screen "columns" and "rows" -- negatives apply
  1944.  * NOTE some flicker may occur                                              */
  1945.  
  1946. void txt_scroll_off(shortint direction);
  1947. /* smoothly scrolls screen off in "direction"                               */
  1948.  
  1949. void txt_scroll_on(shortint direction);
  1950. /* smoothly scrolls screen on in "direction"                                */
  1951.  
  1952. void txt_scroll_over(int scanlines);
  1953. /* smoothly scrolls "scanlines" of a screen overtop another screen --
  1954.    negative "scanlines" means scroll down (off screen)                      */
  1955.  
  1956. void txt_scroll_rows(byte row, byte height, shortint horz_scroll);
  1957. /* smoothly scrolls screen rows "height" beginning at "row"
  1958.  * scrolls "horz_scroll" columns -- negatives apply                         */
  1959.  
  1960. void txt_scroll_window(byte x, byte y, byte length, byte height,
  1961.                        shortint horz_scroll, shortint vert_scroll);
  1962. /* smoothly scrolls screen region with corner at "x","y", x-length
  1963.    "length", and y-height "height" in direction "direction","horz_scroll"
  1964.    characters and "vert_scroll" rows -- negatives apply                     */
  1965.  
  1966. void txt_set_abs(word offset);
  1967. /* sets offset of text page                                                 */
  1968.  
  1969. void txt_set_act(byte page);
  1970. /* sets text page "page" as active
  1971.  * if "page" = TEXTPAGEVISUAL, active page becomes current visual page
  1972.  * if "page" = TEXTPAGELAST, last page becomes active page                  */
  1973.  
  1974. void txt_set_rel(int columns, int rows);
  1975. /* sets horz offset "columns" and vert offset "rows" from original offset   */
  1976.  
  1977. void txt_set_vis(byte page);
  1978. /* sets a text page as visual, or seen
  1979.  * if "page" = TEXTPAGEACTIVE, visual page becomes current active page
  1980.  * if "page" = TEXTPAGELAST, last page becomes visual page                  */
  1981.  
  1982. void txt_split(word line);          /* splits visual page at "line" (0-400) */
  1983.  
  1984. /* ------------------------------------------------------------------------ */
  1985. /* -----------------  TEXT ANIMATION FUNCTION PROTOTYPES  ----------------- */
  1986.  
  1987. /* :(NONE YET :( */
  1988.  
  1989. /* ------------------------------------------------------------------------ */
  1990. /* -----------------  TEXT ATTRIBUTE FUNCTION PROTOTYPES  ----------------- */
  1991.  
  1992. char txt_attr_save(byte x, byte y, byte *fgclr, byte *bgclr);
  1993. /* stores foreground color at "x","y" into "fgclr" and background color
  1994.    into "bgclr"
  1995.  * if "fgclr" = NULL, foreground is not stored
  1996.  * if "bgclr" = NULL, background is not stored
  1997.  * RETURNS: ASCII value of character at "x","y"                             */
  1998.  
  1999. char txt_attr_show(byte x, byte y, byte fgclr, byte bgclr, int count);
  2000. /* prints "count" fgcolors "fgclr" and bgcolors "bgclr" at "x","y"
  2001.  * if "fgclr" = NO, foreground is not modified
  2002.  * if "bgclr" = NO, background is not modified
  2003.  * if "x" and "y" both equal TCUR, advances the cursor position to one
  2004.    past the last attribute printed
  2005.  * RETURNS: ASCII value of character at "x","y"                             */
  2006.  
  2007. void txt_attrs_fill(byte x, byte y,
  2008.                     byte length, byte height, byte fgclr, byte bgclr);
  2009. /* the region with corner "x","y", x-length "length", and y-height
  2010.    "height" is filled in fgcolor "fglcr" and bgcolor "bgclr"
  2011.  * if "fgclr" = NO, foreground is not modified
  2012.  * if "bgclr" = NO, background is not modified                              */
  2013.  
  2014. word txt_attrs_need(byte length, byte height);
  2015. /* RETURNS: memory requirement for a "txt_attrs_save"ed image of
  2016.    x-length "length" and y-height "height"                                  */
  2017.  
  2018. void txt_attrs_save(byte x, byte y,
  2019.                     byte length, byte height, textimagedata *attrs);
  2020. /* stores the region of attributes from corner "x","y" with x-length
  2021.    "length" and y-height "height" into "attrs"
  2022.  * if "x" = MEM, "attrs.x" is used
  2023.  * if "y" = MEM, "attrs.y" is used
  2024.  * if "length" = MEM, "attrs.length" is used
  2025.  * if "height" = MEM, "attrs.height" is used                                */
  2026.  
  2027. void txt_attrs_show(byte x, byte y,
  2028.                     byte fgclr, byte bgclr, textimagedata *attrs);
  2029. /* prints the region of attributes "attrs" at top-left corner "x","y"
  2030.  * if "x" = MEM,  "attrs.x" is used
  2031.  * if "y" = MEM,  "attrs.y" is used
  2032.  * if "fgclr" = NO,  foreground color is not modified
  2033.               = YES, modifies foreground with stored colors
  2034.               = MEM, "attrs.fgclr" is used
  2035.  * if "bgclr" = NO,  background color is not modified
  2036.               = YES, modifies background with stored colors
  2037.               = MEM, "attrs.bgclr" is used                                  */
  2038.  
  2039. byte txt_bg_get(byte x, byte y);    /* RETURNS: background color at "x","y" */
  2040.  
  2041. byte txt_fg_get(byte x, byte y);    /* RETURNS: foreground color at "x","y" */
  2042.  
  2043. /* ------------------------------------------------------------------------ */
  2044. /* -----------------  TEXT CHARACTER FUNCTION PROTOTYPES  ----------------- */
  2045.  
  2046. void txt_chr_attr_save(byte x, byte y, byte *fgclr, byte *bgclr, char *ch);
  2047. /* stores foreground color at "x","y" into "fgclr", background color into
  2048.    "bgclr", and ASCII character into "ch"
  2049.  * if "fgclr" = NULL, foreground is not stored
  2050.  * if "bgclr" = NULL, background is not stored
  2051.  * if "ch" = NULL, character is not stored
  2052.  * RETURNS: ASCII value of character at "x","y"                             */
  2053.  
  2054. char txt_chr_attr_show(byte x, byte y,
  2055.                        byte fgclr, byte bgclr, char ch, int count);
  2056. /* prints "count" characters "ch" in fgcolor "fgclr" and bgcolor "bgclr"
  2057.    at "x","y"
  2058.  * if "fgclr" = NO, foreground is not modified
  2059.  * if "bgclr" = NO, background is not modified
  2060.  * if "x" and "y" both equal TCUR, advances the cursor position to one
  2061.    past the last attribute printed
  2062.  * RETURNS: ASCII value of first character overwritten                      */
  2063.  
  2064. char txt_chr_erase(byte x, byte y, int count);
  2065. /* overwrites "count" characters at "x","y" with spaces
  2066.  * RETURNS: ASCII value of first character overwritten                      */
  2067.  
  2068. char txt_chr_get(byte x, byte y);
  2069. /* RETURNS: ASCII value of character at "x","y"                             */
  2070.  
  2071. char txt_chr_show(byte x, byte y, char ch, int count);
  2072. /* prints "count" characters "ch" at "x","y"
  2073.  * RETURNS: ASCII value of first character overwritten                      */
  2074.  
  2075. char txt_chrattr_save(byte x, byte y, word *chrattr);
  2076. /* stores character with its attribute at "x","y" into "chrattr"
  2077.  * RETURNS: ASCII value of character that was saved                         */
  2078.  
  2079. char txt_chrattr_show(byte x, byte y,
  2080.                       byte fgclr, byte bgclr, word chrattr, int count);
  2081. /* prints "count" characters with attributes, from "chrattr", at "x","y"
  2082.  * if "fgclr" = NO, foreground is not modified
  2083.  * if "bgclr" = NO, background is not modified
  2084.  * RETURNS: ASCII value of first character overwritten                      */
  2085.  
  2086. char txt_chrattrs_fill(byte x, byte y, byte length, byte height,
  2087.                        byte fgclr, byte bgclr, char ch);
  2088. /* the region with corner "x","y", x-length "length", and y-height "height"
  2089.    is filled with "ch" in "fgclr","bgclr"
  2090.  * if "fgclr" = NO, foreground is not modified
  2091.  * if "bgclr" = NO, background is not modified
  2092.  * if "ch" = NO, no character is written
  2093.  * RETURNS: ASCII value of first character overwritten                      */
  2094.  
  2095. word txt_chrattrs_need(byte length, byte height);
  2096. /* RETURNS: memory requirement for a "txt_chrattrs_save"ed image            */
  2097.  
  2098. void txt_chrattrs_save(byte x, byte y,
  2099.                        byte length, byte height, textimagedata *chrattrs);
  2100. /* stores the region of characters and their attributes from corner
  2101.    "x","y" with x-length "length" and y-height "height" into "chrattrs"
  2102.  * if "x" = MEM, "chrattrs.x" is used
  2103.  * if "y" = MEM, "chrattrs.y" is used
  2104.  * if "length" = MEM, "chrattrs.length" is used
  2105.  * if "height" = MEM, "chrattrs.height" is used                             */
  2106.  
  2107. void txt_chrattrs_show(byte x, byte y,
  2108.                        byte fgclr, byte bgclr, textimagedata *chrattrs);
  2109. /* prints a region of character and their attributes "chrattrs" at
  2110.    top-left corner "x","y"
  2111.  * if "x" = MEM, "chrattrs.x" is used
  2112.  * if "y" = MEM, "chrattrs.y" is used
  2113.  * if "fgclr" = NO,  foreground color is not modified
  2114.               = YES, modifies foreground with stored colors
  2115.               = MEM, "chrattrs.fgclr" is used
  2116.  * if "bgclr" = NO,  background color is not modified
  2117.               = YES, modifies background with stored colors
  2118.               = MEM, "chrattrs.bgclr" is used                               */
  2119.  
  2120. void txt_chrattrs_show_char(byte x, byte y, byte x_timage, byte y_timage,
  2121.                             byte fgclr, byte bgclr, textimagedata *chrattrs);
  2122. /* prints one character and its attributes from "x_timage","y_timage" of
  2123.    "chrattrs" at screen "x","y"
  2124.  * if "x" = MEM, "chrattrs.x" is used
  2125.  * if "y" = MEM, "chrattrs.y" is used
  2126.  * if "fgclr" = NO,  foreground color is not modified
  2127.               = YES, modifies foreground with stored colors
  2128.               = MEM, "chrattrs.fgclr" is used
  2129.  * if "bgclr" = NO,  background color is not modified
  2130.               = YES, modifies background with stored colors
  2131.               = MEM, "chrattrs.bgclr" is used                               */
  2132.  
  2133. void txt_chrattrs_show_str(byte x, byte y, byte x_timage, byte y_timage,
  2134.                byte length,  byte fgclr, byte bgclr, textimagedata *chrattrs);
  2135. /* prints string of character and their attributes from "x_timage","y_timage"
  2136.    of "chrattrs" at screen "x","y"
  2137.  * if "x" = MEM, "chrattrs.x" is used
  2138.  * if "y" = MEM, "chrattrs.y" is used
  2139.  * if "fgclr" = NO,  foreground color is not modified
  2140.               = YES, modifies foreground with stored colors
  2141.               = MEM, "chrattrs.fgclr" is used
  2142.  * if "bgclr" = NO,  background color is not modified
  2143.               = YES, modifies background with stored colors
  2144.               = MEM, "chrattrs.bgclr" is used                               */
  2145.  
  2146. void txt_chrattrs_show_region(byte x, byte y, byte x_timage, byte y_timage,
  2147.    byte length, byte height, byte fgclr, byte bgclr, textimagedata *chrattrs);
  2148. /* prints region of character and their attributes from "x_timage","y_timage"
  2149.    of "chrattrs" at screen "x","y"
  2150.  * if "x" = MEM, "chrattrs.x" is used
  2151.  * if "y" = MEM, "chrattrs.y" is used
  2152.  * if "fgclr" = NO,  foreground color is not modified
  2153.               = YES, modifies foreground with stored colors
  2154.               = MEM, "chrattrs.fgclr" is used
  2155.  * if "bgclr" = NO,  background color is not modified
  2156.               = YES, modifies background with stored colors
  2157.               = MEM, "chrattrs.bgclr" is used                               */
  2158.  
  2159. void txt_chrs_erase(byte x, byte y, textimagedata *chrs);
  2160. /* overwrites "chrs" with corner at "x","y" with spaces
  2161.  * if "x" = MEM, "chrs.x" is used
  2162.  * if "y" = MEM, "chrs.y" is used                                           */
  2163.  
  2164. void txt_chrs_fill(byte x, byte y, byte length, byte height, char ch);
  2165. /* the region with corner "x","y", x-length "length", and y-height
  2166.    "height" is filled with character "ch"                                   */
  2167.  
  2168. word txt_chrs_need(byte length, byte height);
  2169. /* RETURNS: memory requirement for a "txt_chrs_save"ed image                */
  2170.  
  2171. void txt_chrs_save(byte x, byte y,
  2172.                    byte length, byte height, textimagedata *chrs);
  2173. /* stores the region of characters from corner "x","y" with x-length
  2174.    "length" and y-height "height" into "chrs"
  2175.  * if "length" = MEM, "chrs.length" is used
  2176.  * if "height" = MEM, "chrs.height" is used                                 */
  2177.  
  2178. void txt_chrs_show(byte x, byte y, textimagedata *chrs);
  2179. /* prints the region of character "chrs" with top-left corner "x","y"
  2180.  * if "x" = MEM, "chrs.x" is used
  2181.  * if "y" = MEM, "chrs.y" is used                                           */
  2182.  
  2183. /* ------------------------------------------------------------------------ */
  2184. /* ------------------  TEXT CURSOR FUNCTION PROTOTYPES  ------------------- */
  2185.  
  2186. void cur_get(cursordata *curdata);
  2187. /* fills structure "curdata" with all text cursor information               */
  2188.  
  2189. void cur_get_abs(cursordata *curdata);
  2190. /* fills structure "curdata" with all text cursor information, as reported by
  2191.    VGA card                                                                 */
  2192.  
  2193. void cur_get_coord(byte *x, byte *y);
  2194. /* stores cursor abscissa in "x" and cursor ordinate in "y" on active page
  2195.  * if "y" = NULL, "x" is assumed to be "byte *xy"                           */
  2196.  
  2197. void cur_get_coord_abs(byte *x, byte *y);
  2198. /* stores cursor abscissa in "x" and cursor ordinate in "y", as reported by
  2199.    VGA card
  2200.  * if "y" = NULL, "x" is assumed to be "byte *xy"                           */
  2201.  
  2202. void cur_get_shape(byte *start, byte *end);
  2203. /* gets cursor shape on active page
  2204.  * stores starting scan line into "start", ending scan line into "end"
  2205.  * if "end" = NULL, "start" is assumed to be "byte *start_end"              */
  2206.  
  2207. void cur_get_shape_abs(byte *start, byte *end);
  2208. /* gets cursor shape as reported by VGA card
  2209.  * stores starting scan line into "start", ending scan line into "end"
  2210.  * if "end" = NULL, "start" is assumed to be "byte *start_end"              */
  2211.  
  2212. byte cur_get_x(void);
  2213. /* RETURNS: cursor abscissa on active page                                  */
  2214.  
  2215. byte cur_get_x_abs(void);
  2216. /* RETURNS:cursor abscissa as reported by VGA card                          */
  2217.  
  2218. byte cur_get_y(void);
  2219. /* RETURNS: cursor ordinate on active page                                  */
  2220.  
  2221. byte cur_get_y_abs(void);
  2222. /* RETURNS:cursor ordinate as reported by VGA card                          */
  2223.  
  2224. boolean cur_is_on(void);
  2225. /* RETURNS:TRUE if text cursor is on, FALSE if not                          */
  2226.  
  2227. void cur_off(void);
  2228. /* turns cursor off                                                         */
  2229.  
  2230. void cur_on(void);
  2231. /* turns cursor on                                                          */
  2232.  
  2233. void cur_set(cursordata *curdata);
  2234. /* sets cursor statistics according to "curdata"                            */
  2235.  
  2236. void cur_set_bios(cursordata *curdata);
  2237. /* sets cursor statatics according to "curdata" via BIOS                    */
  2238.  
  2239. byte cur_set_coord(byte x, byte y);
  2240. /* sets cursor to "x","y"
  2241.  * if "x" = MCUR, cursor abscissa is set to mouse abscissa
  2242.  * if "y" = MCUR, cursor ordinate is set to mouse ordinate
  2243.  * RETURNS: cursor abscissa                                                 */
  2244.  
  2245. void cur_set_coord_bios(byte x, byte y);
  2246. /* sets cursor to "x","y" via BIOS                                          */
  2247.  
  2248. void cur_set_shape(byte start, byte end);
  2249. /* defines new cursor shape, starting at scan line "start", ending at
  2250.    scan line "end"
  2251.  * if "start" = NO, starting scan line of cursor is not modified
  2252.  * if "end" = NO, ending scan line of cursor is not modified
  2253.  * "start" and end" must be between 0 - 31                                  */
  2254.  
  2255. void cur_set_shape_bios(byte start, byte end);
  2256. /* defines new cursor shape, starting at scan line "start", ending at
  2257.    scan line "end"
  2258.  * "start" and end" must be between 0 - 31                                  */
  2259.  
  2260. byte cur_set_x(byte x);
  2261. /* sets cursor abscissa to "x"
  2262.  * RETURNS: cursor ordinate                                                 */
  2263.  
  2264. byte cur_set_x_bios(byte x);
  2265. /* sets cursor abscissa to "x" via BIOS
  2266.  * RETURNS: cursor ordinate                                                 */
  2267.  
  2268. byte cur_set_y(byte y);
  2269. /* sets cursor ordinate to "y"
  2270.  * RETURNS: cursor abscissa                                                 */
  2271.  
  2272. byte cur_set_y_bios(byte y);
  2273. /* sets cursor ordinate to "y" via bios
  2274.  * RETURNS: cursor abscissa                                                 */
  2275.  
  2276. /* ------------------------------------------------------------------------ */
  2277. /* -----------------  TEXT USER INPUT FUNCTION PROTOTYPES  ---------------- */
  2278.  
  2279. int txt_get_let(byte x, byte y, char *str, byte max, byte fillchar,
  2280.                 char *msg, byte fgclr, byte bgclr, char *def);
  2281. /* accepts only alphabet character input from keyboard into "str"
  2282.  * accepts a maximum of "max" characters; if "max" = MAX, accepts a
  2283.    maximum of "str_len(str)" characters
  2284.  * prints message "msg" at "x","y" followed by default response "def"
  2285.  * fills empty response space with "fillchar", unless "fillchar" = NO
  2286.  * colors response space with "fgclr","bgclr"
  2287.  * will not allow input to exceed screen limit
  2288.  * hides text cursor and restores its position upon return
  2289.  * RETURNS: number of characters of input
  2290.             -1 if <ESC> is pressed
  2291.             -2 if an error occurred                                         */
  2292.  
  2293. int txt_get_num(byte x, byte y, int *input, byte max, byte fillchar,
  2294.                 char *msg, byte fgclr, byte bgclr, char *def);
  2295. /* accepts only numeric digit input and '+','-' from keyboard into "input"
  2296.  * accepts a maximum of "max" characters; input is allowed to be -32768..32767
  2297.  * prints message "message" at "x","y" followed by default response "def"
  2298.  * fills empty response space with "fillchar", unless "fillchar" = NO
  2299.  * colors response space with "fgclr","bgclr"
  2300.  * will not allow input to exceed screen limit
  2301.  * hides text cursor and restores its position upon return
  2302.  * RETURNS: number of characters of input
  2303.             -1 if <ESC> is pressed
  2304.             -2 if an error occurred                                         */
  2305.  
  2306. int txt_get_numu(byte x, byte y, word *input, byte max, byte fillchar,
  2307.                  char *msg, byte fgclr, byte bgclr, char *def);
  2308. /* accepts only numeric digit input from keyboard into "input"
  2309.  * accepts a maximum of "max" characters; input is allowed between 0..65535
  2310.  * prints message "message" at "x","y" followed by default response "def"
  2311.  * fills empty response space with "fillchar", unless "fillchar" = NO
  2312.  * colors response space with "fgclr","bgclr"
  2313.  * will not allow input to exceed screen limit
  2314.  * hides text cursor and restores its position upon return
  2315.  * RETURNS: number of characters of input
  2316.             -1 if <ESC> is pressed
  2317.             -2 if an error occurred                                         */
  2318.  
  2319. int txt_get_str(byte x, byte y, char *str, byte max, byte fillchar,
  2320.                 char *msg, byte fgclr, byte bgclr, char *def);
  2321. /* accepts all ASCII character input from keyboard into "str"
  2322.  * accepts a maximum of "max" characters; if "max" = MAX, accepts a maximum
  2323.    of "str_len(str)" characters
  2324.  * prints message "message" at "x","y" followed by default response
  2325.    "def"
  2326.  * fills empty response space with "fillchar", unless "fillchar" = NO
  2327.  * colors response space with "fgclr","bgclr"
  2328.  * will not allow input to exceed screen limit
  2329.  * hides text cursor and restores its position upon return
  2330.  * RETURNS: number of characters of input
  2331.             -1 if <ESC> is pressed
  2332.             -2 if an error occurred                                         */
  2333.  
  2334. /* ------------------------------------------------------------------------ */
  2335. /* -------------------  TEXT STRING FUNCTION PROTOTYPES  ------------------ */
  2336.  
  2337. void txt_str_attr_show(byte x, byte y,
  2338.                        byte fgclr, byte bgclr, char *str, byte command);
  2339. /* prints string "str" in fgcolor "fgclr" and bgcolor "bgclr" at "x","y"
  2340.  * if "fgclr" = NO,  foreground color is not modified
  2341.  * if "bgclr" = NO,  background color is not modified
  2342.  * if "command" = ALIGN_NONE   no command
  2343.                 = ALIGN_HORZ   horizontal center; shifts odd lengths left
  2344.                 = ALIGN_VERT   vertical center; shifts odd lengths up
  2345.                 = ALIGN_CENTER horizontal and vertical center
  2346.                 = ALIGN_RIGHT  right justify; flush to right margin         */
  2347.  
  2348. word txt_str_erase(byte x, byte y, char *str, byte command);
  2349. /* overwrites "str" at "x","y" with blanks (ASCII 32)
  2350.  * if "command" = ALIGN_NONE   no command
  2351.                 = ALIGN_HORZ   horizontal center; shifts odd lengths left
  2352.                 = ALIGN_VERT   vertical center; shifts odd lengths up
  2353.                 = ALIGN_CENTER horizontal and vertical center
  2354.                 = ALIGN_RIGHT  right justify; flush to right margin
  2355.  * RETURNS: length of "str"                                                 */
  2356.  
  2357. word txt_str_erase_pr(byte x, byte y, printdata *prdata);
  2358. /* overwrites "printdata.text" at "x","y" with blanks (ASCII 32)
  2359.  * if "x" = MEM, "prdata.x" is used
  2360.  * if "y" = MEM, "prdata.y" is used
  2361.  * RETURNS: length of "prdata.string"                                       */
  2362.  
  2363. word txt_str_save(byte x, byte y, byte length, char *str, byte command);
  2364. /* reads "length" characters from "x","y" into "str"
  2365.  * if "length" = NULL, uses length of "str" as number of characters to read
  2366.  * The NULL character is appended as last character in "str"
  2367.  * if "command" = ALIGN_NONE   no command
  2368.                 = ALIGN_HORZ   horizontal center; shifts odd lengths left
  2369.                 = ALIGN_VERT   vertical center; shifts odd lengths up
  2370.                 = ALIGN_CENTER horizontal and vertical center
  2371.                 = ALIGN_RIGHT  right justify; flush to right margin
  2372.  * RETURNS: length of "str"                                                 */
  2373.  
  2374. word txt_str_show(byte x, byte y, char *str, byte command);
  2375. /* prints string "str" at "x","y"
  2376.  * if "command" = ALIGN_NONE   no command
  2377.                 = ALIGN_HORZ   horizontal center; shifts odd lengths left
  2378.                 = ALIGN_VERT   vertical center; shifts odd lengths up
  2379.                 = ALIGN_CENTER horizontal and vertical center
  2380.                 = ALIGN_RIGHT  right justify; flush to right margin
  2381.  * RETURNS: length of "str"                                                 */
  2382.  
  2383. word txt_strattr_need(byte length);
  2384. /* RETURNS: memory requirement for "txt_strattr_save"ed image of
  2385.    x-length "length"                                                        */
  2386.  
  2387. word txt_strattr_save(byte x, byte y, shortint length,textimagedata *strattr);
  2388. /* reads "length" characters and their attributes from "x","y" to "strattr"
  2389.  * if "length" = MEM, "strattr.length" is used
  2390.  * RETURNS: character count of "strattr" (which is length / 2)              */
  2391.  
  2392. word txt_strattr_show(byte x, byte y, byte fgclr, byte bgclr,
  2393.                       textimagedata *strattr, byte command);
  2394. /* prints string with attributes "strattr" at "x","y"
  2395.  * if "fgclr" = NO,  foreground color is not modified
  2396.               = YES, modifies foreground with stored colors
  2397.               = MEM, "strattr.fgclr" is used
  2398.  * if "bgclr" = NO,  background color is not modified
  2399.               = YES, modifies background with stored colors
  2400.               = MEM, "strattr.bgclr" is used
  2401.  * if "command" = ALIGN_NONE   no command
  2402.                 = ALIGN_HORZ   horizontal center; shifts odd lengths left
  2403.                 = ALIGN_VERT   vertical center; shifts odd lengths up
  2404.                 = ALIGN_CENTER horizontal and vertical center
  2405.                 = ALIGN_RIGHT  right justify; flush to right margin
  2406.  * RETURNS: character count of "strattr" (which is length / 2)              */
  2407.  
  2408. /* ------------------------------------------------------------------------ */
  2409. /* -------------------  TEXT WINDOW FUNCTION PROTOTYPES  ------------------ */
  2410.  
  2411. word win_define(void);
  2412. /* defines a new window                                                     */
  2413.  
  2414. void win_move(void);
  2415. /* moves a window to absolute coordinates                                   */
  2416.  
  2417. void win_move_rel(void);
  2418. /* moves a window relative to its current position                          */
  2419.  
  2420. void win_scroll(int horz, int vert, windowdata *win);
  2421. /* scrolls window "win" "horz" chars horizontally and "vert" chars
  2422.    vertically -- negatives apply                                            */
  2423.  
  2424. /* ------------------------------------------------------------------------ */
  2425. /* -----------------------  VGA FUNCTION PROTOTYPES  ---------------------- */
  2426.  
  2427. void fade_in(void);                         /* fade into a screen           */
  2428.  
  2429. void fade_out(void);                        /* fade a screen to black       */
  2430.  
  2431. boolean isit_color(void);   /* RETURNS: TRUE if color capable, FALSE if not */
  2432.  
  2433. boolean isit_ega(void);     /* RETURNS: TRUE if   EGA capable, FALSE if not */
  2434.  
  2435. boolean isit_vga(void);     /* RETURNS: TRUE if   VGA capable, FALSE if not */
  2436.  
  2437. boolean isit_svga(void);    /* RETURNS: TRUE if  SVGA capable, FALSE if not */
  2438.  
  2439. /* ------------------------------------------------------------------------ */
  2440. /* -----------------  VGA 640x480x16 FUNCTION PROTOTYPES  ----------------- */
  2441.  
  2442. void _16_boxfill(int x, int y, int length, int height, int color, int how);
  2443. /* creates a solid box of color "color" with one corner at "x","y" and
  2444.    x-length "length" and y-height "height" (which can be negative)
  2445.  * RETURNS: 0 if successful or -1 if box dimensions are off-screen
  2446.  * "how" determines how image is drawn: COPY_IMAGE - draws image
  2447.                                         AND_IMAGE  - ANDs image
  2448.                                         OR_IMAGE   - ORs image
  2449.                                         XOR_IMAGE  - XORs image
  2450.          COPY_IMAGE_SET - draws image and sets to current scroll
  2451.          AND_IMAGE_SET  - ANDs  image and sets to current scroll
  2452.          OR_IMAGE_SET   - ORs   image and sets to current scroll
  2453.          XOR_IMAGE_SET  - XORs  image and sets to current scroll            */
  2454.  
  2455. void _16_boxoutline(int x, int y, int length, int height, int color,int how);
  2456. /* creates an outline of a box color "color" with one corner at "x","y"
  2457.    and x-length "length" and y-height "height" (which can be negative)
  2458.  * "length" and "height" must be at least 2
  2459.  * RETURNS: 0 if successful or -1 if box dimensions are off-screen
  2460.  * "how" determines how image is drawn: COPY_IMAGE - draws image
  2461.                                         AND_IMAGE  - ANDs image
  2462.                                         OR_IMAGE   - ORs image
  2463.                                         XOR_IMAGE  - XORs image
  2464.          COPY_IMAGE_SET - draws image and sets to current scroll
  2465.          AND_IMAGE_SET  - ANDs  image and sets to current scroll
  2466.          OR_IMAGE_SET   - ORs   image and sets to current scroll
  2467.          XOR_IMAGE_SET  - XORs  image and sets to current scroll            */
  2468.  
  2469. void _16_floodall(int color, int scroll);
  2470. /* floods a screen-size with color "color
  2471.  * "scroll" determines relative to what flood will occur:
  2472.                                               TRUE  - relative to screen
  2473.                                               FALSE - relative to A000:0000 */
  2474.  
  2475. void _16_floodallall(int color);
  2476. /* floods a 640x816 region of video RAM with color "color"                  */
  2477.  
  2478. void _16_linebiglen(int x, int y, int length,
  2479.                     int height, int color, int how, int dimensions);
  2480. /* draws line with one end at "x","y", x-length "length", and y-height
  2481.    "height" in color "color"
  2482.  * "how" determines how image is drawn: COPY_IMAGE - draws image
  2483.                                         AND_IMAGE  - ANDs image
  2484.                                         OR_IMAGE   - ORs image
  2485.                                         XOR_IMAGE  - XORs image
  2486.          COPY_IMAGE_SET - draws image and sets to current scroll
  2487.          AND_IMAGE_SET  - ANDs  image and sets to current scroll
  2488.          OR_IMAGE_SET   - ORs   image and sets to current scroll
  2489.          XOR_IMAGE_SET  - XORs  image and sets to current scroll
  2490.  * line is drawn using user-specified block size "dimensions"               */
  2491.  
  2492. void _16_linebigxy(int x1, int y1, int x2, int y2,
  2493.                    int color, int how, int dimensions);
  2494. /* draws a line from "x1","y1" to "x2","y2" in color "color"
  2495.  * line is drawn using user-specified block size "dimensions"
  2496.  * "how" determines how image is drawn: COPY_IMAGE - draws image
  2497.                                         AND_IMAGE  - ANDs image
  2498.                                         OR_IMAGE   - ORs image
  2499.                                         XOR_IMAGE  - XORs image
  2500.          COPY_IMAGE_SET - draws image and sets to current scroll
  2501.          AND_IMAGE_SET  - ANDs  image and sets to current scroll
  2502.          OR_IMAGE_SET   - ORs   image and sets to current scroll
  2503.          XOR_IMAGE_SET  - XORs  image and sets to current scroll            */
  2504.  
  2505. void _16_linelen(int x, int y, int length, int height, int color, int how);
  2506. /* draws line with one end at "x","y", x-length "length", and y-height
  2507.    "height" in color "color"
  2508.  * same as "linexy" but draws line using relative distances
  2509.  * RETURNS: 0 if successful or -1 if line dimensions are off-screen
  2510.  * "how" determines how image is drawn: COPY_IMAGE - draws image
  2511.                                         AND_IMAGE  - ANDs image
  2512.                                         OR_IMAGE   - ORs image
  2513.                                         XOR_IMAGE  - XORs image
  2514.          COPY_IMAGE_SET - draws image and sets to current scroll
  2515.          AND_IMAGE_SET  - ANDs  image and sets to current scroll
  2516.          OR_IMAGE_SET   - ORs   image and sets to current scroll
  2517.          XOR_IMAGE_SET  - XORs  image and sets to current scroll            */
  2518.  
  2519. void _16_linexy(int x1, int y1, int x2, int y2, int color, int how);
  2520. /* draws a line from "x1","y1" to "x2","y2" in color "color"
  2521.  * same as "linecool" but draws line properly
  2522.  * "how" determines how image is drawn: COPY_IMAGE - draws image
  2523.                                         AND_IMAGE  - ANDs image
  2524.                                         OR_IMAGE   - ORs image
  2525.                                         XOR_IMAGE  - XORs image
  2526.          COPY_IMAGE_SET - draws image and sets to current scroll
  2527.          AND_IMAGE_SET  - ANDs  image and sets to current scroll
  2528.          OR_IMAGE_SET   - ORs   image and sets to current scroll
  2529.          XOR_IMAGE_SET  - XORs  image and sets to current scroll
  2530.  * RETURNS: 0 if successful or -1 if line dimensions are off-screen         */
  2531.  
  2532. void _16_pixel(int x, int y, int color, int scroll);
  2533. /* changes pixel at "x","y" to "color"
  2534.  * "scroll" determines relative to what pixel will be set:
  2535.                                               TRUE  - relative to screen
  2536.                                               FALSE - relative to A000:0000 */
  2537.  
  2538. int _16_pixel_avg(int x, int y, int scroll);
  2539. /* "scroll" determines relative to what pixel will be read:
  2540.                                               TRUE  - relative to screen
  2541.                                               FALSE - relative to A000:0000
  2542.  * RETURNS: average color of nine pixels surrounding "x","y"                */
  2543.  
  2544. int _16_pixel_color(int x, int y, int scroll);
  2545. /* "scroll" determines relative to what pixel will be read:
  2546.                                               TRUE  - relative to screen
  2547.                                               FALSE - relative to A000:0000
  2548.  * RETURNS: pixel color at "x","y"                                          */
  2549.  
  2550. boolean _16_pixel_is(int x, int y, int color, int scroll);
  2551. /* "scroll" determines relative to what pixel will be checked:
  2552.                                               TRUE  - relative to screen
  2553.                                               FALSE - relative to A000:0000
  2554.  * RETURNS: TRUE  if pixel at "x","y" is "color"
  2555.             FALSE if not                                                    */
  2556.  
  2557. int _16_popupcolumn(int x, int y, int choice, int maxopts,
  2558.                     char *ptr[], int mousepresent);
  2559. /* a column will pop up at "x","y" with maximum choices "maxopts"
  2560.  * "choice" will be first highlighted menu
  2561.  * "ptr" points to main menu options
  2562.  * "mousepresent" is TRUE if a mouse is present and has been initialized
  2563.    with "ms_init()"                                                         */
  2564.  
  2565. int _16_popupmenu(int x, int y, int choice, int maxmenus,
  2566.                   char *ptr[], int data[][3], char *text[], int mousepresent);
  2567. /* a menu will pop up at "x","y" with maximum choices "maxmenus"
  2568.  * "choice" will be first highlighted menu
  2569.  * "ptr" points to main menu options
  2570.  * "data" holds necessary data
  2571.    [number of submenus], [index into *text], [1 = active, 0 = inactive]
  2572.  * "text" points to all of submenus
  2573.  * "mousepresent" is TRUE if a mouse is present and has been initialized
  2574.    with "ms_init()"                                                         */
  2575.  
  2576. int _16_scrollevel(void);     /* RETURNS: number of rows currently scrolled */
  2577.  
  2578. void _16_scrollrow(int rows);
  2579. /* scrolls screen "rows" rows (+ve scrolls down, -ve scrolls up)
  2580.  * if "rows" = 0, restores video pointer to A000:0000                       */
  2581.  
  2582. void _16_thermal(int x, int y, int length, int height);
  2583. /* scans through each pixel, taking average color of surrounding pixels
  2584.  * "scroll" determines relative to what pixel will be read:
  2585.                                               TRUE  - relative to screen
  2586.                                               FALSE - relative to A000:0000 */
  2587.  
  2588. /* ------------------------------------------------------------------------ */
  2589. /* --------------  VGA 640x480x16 IMAGE FUNCTION PROTOTYPES  -------------- */
  2590.  
  2591. void _16_copy(imagedata *destination, imagedata *source);
  2592. /* copies "source" into "destination"
  2593.  * both must be "_16_c_save"ed, "_16_i_save"ed, or "_16_p_save"ed images
  2594.  * make sure "destination" has been been allocated sufficient memory        */
  2595.  
  2596. void _16_move(int oldx, int oldy, int newx, int newy,
  2597.               int id, imagedata *oldgraph, imagedata *graph[]);
  2598. /* "oldgraph", at "oldx","oldy", is moved
  2599.  * the new image "image" becomes located at "newx","newy"
  2600.  * if "oldx" = MCUR, mouse cursor abscissa is used
  2601.              = MEM,  "oldgraph.x" is used
  2602.  * if "oldy" = MCUR, mouse cursor ordinate is used
  2603.              = MEM,  "oldgraph.y" is used
  2604.  * if "newx" = MCUR, mouse cursor abscissa is used
  2605.              = MEM,  "graph.x" is used
  2606.  * if "newy" = MCUR, mouse cursor ordinate is used
  2607.              = MEM,  "graph.y" is used
  2608.  * "segment" determines memory location of background image
  2609.  * "id" is a unique number indexing
  2610.  * "memoryidentity" that identifies graphic (it is a constant)
  2611.  * "segment" determines memory location of background image
  2612.  * two global arrays required: "memoryidentity" and "memoryaddress"
  2613.      unsigned int memoryidentity[MAXGRAPHICS];
  2614.      void *memoryaddress[MAXGRAPHICS];
  2615.    DO NOT MODIFY THESE VARIABLES -- THEY ARE USED BY THE ASSEMBLER ROUTINES
  2616.    "memoryidentity" is a unique graphic number for each separate image
  2617.    "memoryadddress" is an array of video memory offsets for each image
  2618.  * this procedure will animate "_16_c_save"ed images                        */
  2619.  
  2620. /* ------------------------------------------------------------------------ */
  2621. /* ----------  VGA 640x480x16 COMPRESS IMAGE FUNCTION PROTOTYPES  --------- */
  2622.  
  2623. /* use all of these routines only with images saved by "_16_c_save"         */
  2624.  
  2625. void _16_c_move(int oldx, int oldy, int newx, int newy,
  2626.                 imagedata *oldgraph, imagedata *graph, imagedata *segment[]);
  2627. /* "oldgraph", at "oldx","oldy", is moved
  2628.  * the new image "image" becomes located at "newx","newy"
  2629.  * if "oldx" = MCUR, mouse cursor abscissa is used
  2630.              = MEM,  "oldgraph.x" is used
  2631.  * if "oldy" = MCUR, mouse cursor ordinate is used
  2632.              = MEM,  "oldgraph.y" is used
  2633.  * if "newx" = MCUR, mouse cursor abscissa is used
  2634.              = MEM,  "graph.x" is used
  2635.  * if "newy" = MCUR, mouse cursor ordinate is used
  2636.              = MEM,  "graph.y" is used
  2637.  * "segment" determines memory location of background image                 */
  2638.  
  2639. unsigned int _16_c_need_scrn(int left, int top, int length, int height);
  2640. /* RETURNS: memory requirement of image with top-left corner at
  2641.    "left","top" and x-length "length" and y-height "height"                 */
  2642.  
  2643. unsigned int _16_c_need_wrst(int length, int height);
  2644. /* RETURNS: worst-case memory requirement of theoretical image with
  2645.    x-length "length" and y-height "height"
  2646.  * use only with "_16_c_save"                                               */
  2647.  
  2648. int _16_c_percent(imagedata *image);
  2649. /* RETURNS: how much percent smaller (or larger) a "_16_c_save"ed image is,
  2650.    compared to an uncompressed "_16_p_save"ed image (relative to 100)
  2651.  * a return value of 40 means 60% smaller whereas 125 means 25% larger      */
  2652.  
  2653. int _16_c_read_off(imagedata *image, int offset);
  2654. /* RETURNS: color of pixel "offset" (starts at 0) of image "image"          */
  2655.  
  2656. int _16_c_read_xy(imagedata *image, int x, int y);
  2657. /* RETURNS: color of pixel at "x","y" of image "image"                      */
  2658.  
  2659. void _16_c_save(int left, int top, int length, int height,
  2660.     int transparency_color, imagedata *image, unsigned int size, int how);
  2661. /* stores screen location with top-left corner at "left","top",
  2662.    x-length "length", y-height "height", and transparency color
  2663.    "transparency_color" into image "image"
  2664.  * if byte size "size" is 0, it will be calculated automatically
  2665.  * "how" determines if image will be saved relative to current
  2666.    scroll or not:  TRUE  - image is saved relative to current scroll
  2667.                    FALSE - image is saved relative to A000:0000             */
  2668.  
  2669. void _16_c_show(int x, int y, imagedata *image, byte how);
  2670. /* writes image "image" at "x","y"
  2671.  * if "x" = -1, "imagedata.x" is used for abscissa and "imagedata.y"
  2672.    is used for ordinate
  2673.  * bit "imagedata.how" determines if image is shown relative to
  2674.    screen (TRUE) or relative to A000:0000 (FALSE)
  2675.  * "how" determines how image is drawn: COPY_IMAGE - draws image
  2676.                                         AND_IMAGE  - ANDs image
  2677.                                         OR_IMAGE   - ORs image
  2678.                                         XOR_IMAGE  - XORs image             */
  2679.  
  2680. void _16_i_to_c(imagedata *destination_c, imagedata *source_i);
  2681. /* converts "_16_i_save"ed image "source_i"
  2682.    into "_16_c_save"ed image "destination_c"                                */
  2683.  
  2684. void _16_p_to_c(imagedata *destination_c, imagedata *source_p);
  2685. /* converts "_16_p_save"ed image "source_p"
  2686.    into "_16_c_save"ed image "destination_c"                                */
  2687.  
  2688. /* ------------------------------------------------------------------------ */
  2689. /* -----------  VGA 640x480x16 PIXEL IMAGE FUNCTION PROTOTYPES  ----------- */
  2690.  
  2691. /* use all of these routines only with images saved by "_16_p_save"         */
  2692.  
  2693. void _16_c_to_p(imagedata *destination_p, imagedata *source_c);
  2694. /* converts "_16_c_save"ed image "source_c"
  2695.    into "_16_p_save"ed image "destination_p"                                */
  2696.  
  2697. void _16_i_to_p(imagedata *destination_p, imagedata *source_i);
  2698. /* converts "_16_i_save"ed image "source_i"
  2699.    into "_16_p_save"ed image "destination_p"                                */
  2700.  
  2701. void _16_p_move(int oldx, int oldy, int newx, int newy,
  2702.                 imagedata *oldgraph, imagedata *graph, imagedata *segment[]);
  2703. /* "oldgraph", at "oldx","oldy", is moved
  2704.  * the new image "image" becomes located at "newx","newy"
  2705.  * if "oldx" = MCUR, mouse cursor abscissa is used
  2706.              = MEM,  "oldgraph.x" is used
  2707.  * if "oldy" = MCUR, mouse cursor ordinate is used
  2708.              = MEM,  "oldgraph.y" is used
  2709.  * if "newx" = MCUR, mouse cursor abscissa is used
  2710.              = MEM,  "graph.x" is used
  2711.  * if "newy" = MCUR, mouse cursor ordinate is used
  2712.              = MEM,  "graph.y" is used
  2713.  * "segment" determines memory location of background image                 */
  2714.  
  2715. unsigned int _16_p_need(int length, int height);
  2716. /* RETURNS: memory requirement of a
  2717.    "_16_p_save"ed image of x-length "length and y-height "height"           */
  2718.  
  2719. int _16_p_read_off(imagedata *image, int offset);
  2720. /* RETURNS: color of pixel "offset" (starts at 0) of image "image"          */
  2721.  
  2722. int _16_p_read_xy(imagedata *image, int x, int y);
  2723. /* RETURNS: color of pixel at "x","y" of image "image"                      */
  2724.  
  2725. void _16_p_save(int left, int top, int length, int height,
  2726.      int transparencycolor, imagedata *image, unsigned int size, int how);
  2727. /* stores screen location with top-left corner at "left","top",
  2728.    x-length "length", y-height "height", and transparency color
  2729.    "transparency_color" into image "image"
  2730.  * if byte size "size" is 0, it will be calculated automatically
  2731.  * "how" determines if image will be saved relative to current
  2732.    scroll or not:  TRUE  - image is saved relative to current scroll
  2733.                    FALSE - image is saved relative to A000:0000             */
  2734.  
  2735. void _16_p_show(int x, int y, imagedata *image, byte how);
  2736. /* writes image "image" at "x","y"
  2737.  * if "x" = -1, "imagedata.x" is used for abscissa and "imagedata.y"
  2738.    is used for ordinate
  2739.  * bit "imagedata.how" determines if image is shown relative to
  2740.    screen (TRUE) or relative to A000:0000 (FALSE)
  2741.  * "how" determines how image is drawn: COPY_IMAGE - draws image
  2742.                                         AND_IMAGE  - ANDs image
  2743.                                         OR_IMAGE   - ORs image
  2744.                                         XOR_IMAGE  - XORs image             */
  2745.  
  2746. /* ------------------------------------------------------------------------ */
  2747. /* -----------  VGA 640x480x16 PLANE IMAGE FUNCTION PROTOTYPES  ----------- */
  2748.  
  2749. /* use all of these routines only with images saved by "_16_i_save"         */
  2750.  
  2751. void _16_c_to_i(imagedata *destination_i, imagedata *source_c);
  2752. /* converts "_16_c_save"ed image "source_c"
  2753.    into "_16_i_save"ed image "destination_i"                                */
  2754.  
  2755. void _16_i_move(int oldx, int oldy, int newx, int newy,
  2756.              imagedata *oldgraph[], imagedata *graph[], imagedata *segment[]);
  2757. void _16_i_move_rect(int oldx, int oldy, int newx, int newy,
  2758.              imagedata *oldgraph[], imagedata *graph[], imagedata *segment[]);
  2759. /* use "_16_i_move_rect" to move rectangular graphics only
  2760.  * "oldgraph", at "oldx","oldy", is moved
  2761.  * "oldgraph[0]" is the full-color graphic and "oldgraph[1]" is the full-
  2762.    black version of the graphic
  2763.  * the new image "image" becomes located at "newx","newy"
  2764.  * "graph[0]" is the full-color graphic and "graph[1]" is the
  2765.    full-black version of the graphic
  2766.  * if "oldx" = MCUR, mouse cursor abscissa is used
  2767.              = MEM,  "oldgraph.x" is used
  2768.  * if "oldy" = MCUR, mouse cursor ordinate is used
  2769.              = MEM,  "oldgraph.y" is used
  2770.  * if "newx" = MCUR, mouse cursor abscissa is used
  2771.              = MEM,  "graph.x" is used
  2772.  * if "newy" = MCUR, mouse cursor ordinate is used
  2773.              = MEM,  "graph.y" is used
  2774.  * "segment" determines memory location of background image                 */
  2775.  
  2776. unsigned int _16_i_need(int length, int height);
  2777. /* RETURNS: memory requirement of a
  2778.    "_16_i_save"ed image of x-length "length and y-height "height"           */
  2779.  
  2780. int _16_i_read_off(imagedata *image, int offset);
  2781. /* RETURNS: color of pixel "offset" (starts at 0) of image "image"          */
  2782.  
  2783. int _16_i_read_xy(imagedata *image, int x, int y);
  2784. /* RETURNS: color of pixel at "x","y" of image "image"                      */
  2785.  
  2786. void _16_i_save(int left, int top, int length, int height,
  2787.                 imagedata *image, unsigned int size, int how);
  2788. /* stores screen location with top-left corner at "left","top",
  2789.    x-length "length", and y-height "height" into image "image"
  2790.  * if byte size "size" is 0, it will be calculated automatically
  2791.  * "how" determines if image will be saved relative to current
  2792.    scroll or not:  TRUE  - image is saved relative to current scroll
  2793.                    FALSE - image is saved relative to A000:0000             */
  2794.  
  2795. void _16_i_show(int x, int y, imagedata *image, byte how);
  2796. /* writes image "image" at "x","y"
  2797.  * if "x" = -1, "imagedata.x" is used for abscissa and "imagedata.y"
  2798.    is used for ordinate
  2799.  * "how" determines how image is drawn: COPY_IMAGE - draws image
  2800.                                         AND_IMAGE  - ANDs image
  2801.                                         OR_IMAGE   - ORs image
  2802.                                         XOR_IMAGE  - XORs image
  2803.  * bit "imagedata.how" determines if image is shown relative to
  2804.    screen (TRUE) or relative to A000:0000 (FALSE)                           */
  2805.  
  2806. void _16_p_to_i(imagedata *destination_i, imagedata *source_p);
  2807. /* converts "_16_p_save"ed image "source_p"
  2808.    into "_16_i_save"ed image "destination_i"                                */
  2809.  
  2810. void _16_restore_bg(int left, int top,
  2811.                     int length, int height, imagedata *segment[]);
  2812. /* restores region of background with top-left
  2813.    corner at "left","top", x-length "length" and y-height "height"
  2814.  * background is stored in segment "segment"
  2815.  * bit "imagedata.how" determines if image is shown relative to
  2816.    screen (TRUE) or relative to A000:0000 (FALSE)                           */
  2817.  
  2818. /* ------------------------------------------------------------------------ */
  2819. /* -----------------  VGA 320x200x256 FUNCTION PROTOTYPES  ---------------- */
  2820.  
  2821. void _256_floodall(int color, int scroll);
  2822. /* floods a screen-size with color "color
  2823.  * "scroll" determines relative to what flood will occur:
  2824.                                               TRUE  - relative to screen
  2825.                                               FALSE - relative to A000:0000 */
  2826.  
  2827. void _256_pixel(int x, int y, int color, int scroll);
  2828. /* changes pixel at "x","y" to "color"
  2829.  * "scroll" determines relative to what pixel will be set:
  2830.                                               TRUE  - relative to screen
  2831.                                               FALSE - relative to A000:0000 */
  2832.  
  2833. /* ------------------------------------------------------------------------ */
  2834.  
  2835. #endif
  2836.  
  2837. /*==========================================================================*/
  2838.  
  2839. // REALiTY
  2840.